Sorting an Array according to the order of another Array

Just define a scorer for your sort method. Here is your code. Try it

var init_arr = ['small', 'big', 'big', 'medium'];

var scorer = {
   small: 0,
   medium: 1,
   big: 2
}

// You can use the same array too. I am creating new one.
var final_arr = init_arr.sort(function(a,b) {
   return scorer[a]-scorer[b];
});

alert(final_arr); //small, medium, big, big

Working Fiddle

This answer works only for the exact case you have described, i.e. where the length of the array is an even multiple of 5 and the values are sorted into small, medium and big and there are twice as many of each small and medium as big.

It may work for any sorted array of values where length % 5 == 0, but the results might not be want you want:

function reOrder(array) {
  var result = [];
  var f = array.length/5; // this must be an integer
  var t;

  for (var i=0; i<f; i++) {
    t = i*2;
    result.push.call(result, array.slice(t, t+2));
    t = f*2 + i*2;
    result.push.call(result, array.slice(t, t+2));
    t = f*4 + i;
    result.push.call(result, array.slice(t, t+1));
  }
  return result; 
} 

var a = ['s','s','s','s','s','s','m','m','m','m','m','m','b','b','b'];
alert(reOrder(a)); // s,s,m,m,b,s,s,m,m,b,s,s,m,m,b

why dont you create 3 arrays and split your data according to sizes, then you can retrieve data in a given order.

like;

SMALL[];
MEDIUM[];
BIG[];

for(i,j,k : upto array lengths : i++,j++,k++){

   nwArray.add(SMALL[i]);
   nwArray.add(SMALL[++i]);
   nwArray.add(MEDIUM[j]);
   nwArray.add(MEDIUM[++j]);
   nwArray.add(BIG[k]);

}

return newArray;

My approach would be looping over the order array and pulling out element till the array is empty or doesn't have the required element.

var sorted = [];
var arr = [
  'small',
  'small',
  'small',
  'small',
  ...
  'medium',
  'medium',
  'medium',
  'medium',
  ...
  'big',
  'big',
  ...
];
var order = ['small', 'small', 'medium', 'medium', 'big'];

out:
while (true) {
  for (var i = 0; i < order.length; i++) {
    var index = arr.indexOf(order[i]);
    if ((index === -1) or (arr.length === 0)) {
      break out;
    } else {
      var elem = arr.splice(index, 1);
      sorted.append(elem[0]);
    }
}

I know this question is old, and you have an answer you are currently using, but I wanted to offer up this example and JSFiddle for a solution that would work with any type of modification you might make to end.

Note anything left over in the original array gets added to the end of the new array, and is not excluded. If there aren't enough items in the array to fill the requirements of order, the missing elements are skipped from the order.

Now, to the function:

function mySort(arr, order) {
    var newAr = [];
    var orIndex = 0;
    while(arr.length != 0) {
        var type = order[orIndex];
        var ind = arr.indexOf(type);
        if(ind != -1) {
            newAr.push(type);
            arr.splice(ind, 1);
        }
        orIndex++;
        if(orIndex >= order.length) {
            orIndex = 0;
        }
    }
    return newAr;
}

What this does, is it takes your example arrays of:

var arrTest = [
  'small',
  'small',
  'small',
  'small',
  'small',
  'small',
  'small',
  'small',
  'medium',
  'medium',
  'medium',
  'medium',
  'medium',
  'medium',
  'medium',
  'medium',
  'big',
  'big',
  'big',
  'big',
];
var orderTest = ['small', 'small', 'medium', 'medium', 'big'];

Now, you can change these all you want, but it does a text search of them, so if you want it sorted, make sure it is the same in both the full array and the order array. Now, to use the function, you would do:

var sortedArray = mySort(arrTest, orderTest);

Or, for how I demonstrate in the Fiddle:

alert(mySort(arrTest, orderTest).join('\n'));

And that should work for any situation that involves the two and the order can easily be modified.

Hope that helps!