Firefox < v3.0 doesn't have a stable Array.sort() function - that is, it doesn't maintain indexes for elements of equal value. This is undefined in the ECMA spec, and has been fixed in Firefox as of version 3 (and curiously enough has been stable in IE all along). As a result, I set out to find a stable, efficient Array.sort() replacement/supplement.
Mergesort is famous for being stable by design, and fast, though not terribly memory efficient. However, it uses a lot of code, and I couldn't manage to find a stable implementation of it.
After doing a little homework, I decided to modify this quicksort pseudocode to get the results I was after. Some would argue that quicksort's worst case performance is slower than mergesort, but for my purposes (small datasets) this was moot.
Here is the resulting code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| // STABLE implementation of quick sort to replace unstable Array.sort method in Firefox
quickSort = function(arr) {
// return if array is unsortable
if (arr.length <= 1){
return arr;
}
var less = Array(), greater = Array();
// select and remove a pivot value pivot from array
// a pivot value closer to median of the dataset may result in better performance
var pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1)[0];
// step through all array elements
for (var x = 0; x < arr.length; x++){
// if (current value is less than pivot),
// OR if (current value is the same as pivot AND this index is less than the index of the pivot in the original array)
// then push onto end of less array
if (
(arr[x] < pivot)
||
(arr[x] == pivot && x < pivotIndex) // this maintains the original order of values equal to the pivot
){
less.push(arr[x]);
}
// if (current value is greater than pivot),
// OR if (current value is the same as pivot AND this index is greater than or equal to the index of the pivot in the original array)
// then push onto end of greater array
else {
greater.push(arr[x]);
}
}
// concatenate less+pivot+greater arrays
return quickSort(less).concat([pivot], quickSort(greater));
}; |
Of course, this will only sort an array of values (strings, numbers), so to sort an array of objects by a given property, I modified the above to produce:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| // STABLE implementation of quick sort to replace unstable Array.sort method in Firefox
// if sorting an array of objects, key = name of object property to compare
// otherwise leave key undefined
quickSort = function(arr, key) {
// return if array is unsortable
if (arr.length <= 1){
return arr;
}
var less = Array(), greater = Array();
// select and remove a pivot value pivot from array
// a pivot value closer to median of the dataset may result in better performance
var pivotIndex = Math.floor(arr.length / 2);
var pivot = arr.splice(pivotIndex, 1)[0];
// step through all array elements
for (var x = 0; x < arr.length; x++){
// if (current value is less than pivot),
// OR if (current value is the same as pivot AND this index is less than the index of the pivot in the original array)
// then push onto end of less array
if (
(
!key // no object property name passed
&&
(
(arr[x] < pivot)
||
(arr[x] == pivot && x < pivotIndex) // this maintains the original order of values equal to the pivot
)
)
||
(
key // object property name passed
&&
(
(arr[x][key] < pivot[key])
||
(arr[x][key] == pivot[key] && x < pivotIndex) // this maintains the original order of values equal to the pivot
)
)
){
less.push(arr[x]);
}
// if (current value is greater than pivot),
// OR if (current value is the same as pivot AND this index is greater than or equal to the index of the pivot in the original array)
// then push onto end of greater array
else {
greater.push(arr[x]);
}
}
// concatenate less+pivot+greater arrays
return quickSort(less, key).concat([pivot], quickSort(greater, key));
}; |
Code samples
Now we can define an array of objects such as:
1
2
3
4
5
6
| var objects = [
{id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
{id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
{id: 3, type: 'fruit', name: 'apple', color: 'red'},
{id: 4, type: 'vegetable', name: 'pepper', color: 'red'}
]; |
Then sort by color with a call to:
7
8
9
10
11
12
13
14
15
| objects = quickSort(objects, 'color');
// sorted
objects = [
{id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
{id: 3, type: 'fruit', name: 'apple', color: 'red'},
{id: 4, type: 'vegetable', name: 'pepper', color: 'red'},
{id: 1, type: 'fruit', name: 'apple', color: 'yellow'}
]; |
Then sort by type:
16
17
18
19
20
21
22
23
24
| objects = quickSort(objects, 'type');
// sorted
objects = [
{id: 3, type: 'fruit', name: 'apple', color: 'red'},
{id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
{id: 2, type: 'vegetable', name: 'tomato', color: 'red'},
{id: 4, type: 'vegetable', name: 'pepper', color: 'red'}
]; |
Then sort by name:
25
26
27
28
29
30
31
32
33
| objects = quickSort(objects, 'name');
// sorted
objects = [
{id: 3, type: 'fruit', name: 'apple', color: 'red'},
{id: 1, type: 'fruit', name: 'apple', color: 'yellow'},
{id: 4, type: 'vegetable', name: 'pepper', color: 'red'},
{id: 2, type: 'vegetable', name: 'tomato', color: 'red'}
]; |