Javascript array match with less complexity

At the cost of space, you can make hash objects and have constant time lookups for contains instead of using O(n) indexOf calls or for loops:

var inputarray = [1, 4, 5, 9];
var array1 = [1, 2, 3, 4, 5, 6, 7];
var array2 = [8, 9, 10, 11, 12, 13, 14];

var array1Hash = Object.create(null);
var array2Hash = Object.create(null);

var outputarray1 = [];
var outputarray2 = [];

array1.forEach(function(e) {
  array1Hash[e] = true;
});
array2.forEach(function(e) {
  array2Hash[e] = true;
});

inputarray.forEach(function(e) {
  if (e in array1Hash) {
    outputarray1.push(e);
  }
  if (e in array2Hash) {
    outputarray2.push(e);
  }
});

document.getElementById('out1').innerHTML = JSON.stringify(outputarray1);
document.getElementById('out2').innerHTML = JSON.stringify(outputarray2);

<pre id="out1"></pre>
<pre id="out2"></pre>

You can use Array.prototype.filter for it:

var inputarray = [1,4,5,9];
var array1 = [1,2,3,4,5,6,7];
var array2 = [8,9,10,11,12,13,14];

function matchEqualElements(arrayToCompare) {

    return function (element) {
        return (arrayToCompare.indexOf(element) !== -1);
    }
}

console.log(inputarray.filter(matchEqualElements(array1)));

console.log(inputarray.filter(matchEqualElements(array2)));

You can use this

var inputarray = [1, 4, 5, 9],
     array1 = [1, 2, 3, 4, 5, 6, 7],
     array2 = [8, 9, 10, 11, 12, 13, 14],
    outputarray1=[],outputarray2=[];

     inputarray.map(function(item){
       for(var i=0;i<array1.length;i++){
         if(array1[i]==item)outputarray1.push(item);
       }
       for(var i=0;i<array2.length;i++){
         if(array2[i]==item)outputarray2.push(item);
       }
     });
    alert(outputarray1);
    alert(outputarray2);

Complexity in terms of less code? There's a library for that: Underscore#intersection.

inputarray = [1, 4, 5, 9];
array1 = [1, 2, 3, 4, 5, 6, 7];
array2 = [8, 9, 10, 11, 12, 13, 14];    
_.union(inputarray, array1);
_.union(inputarray, array2);

Output:

=> [1, 4, 5]
=> [9]

Algorithmic complexity, you're probably looking at O(n*m) worst case, but you could optimize with sorted arrays.

function intersection(a1, a2) {
  var results = [],
    i = 0,
    j = 0;

  while (i < a1.length && j < a2.length) {
    if (a1[i] === a2[j]) {
      results.push(a1[i]);
      i++;
      j++;
    } else if (a1[i] > a2[j]) {
      j++;
    } else if (a1[i] < a2[j]) {
      i++;
    }
  }

  return results;
}

console.log(intersection([1, 2, 3, 4, 5], [3, 5, 6, 7]));
// [3, 5]
console.log(intersection([1, 2, 3, 4, 5], [1, 2, 5, 6]));
// [1, 2, 5]

This gets you O(n+m) which if n >>> m, is just O(n).