But What surprised me was that, one of the following netizens replied that the sort method of Array itself in javascript was the fastest, faster than the fast sorting algorithm. At that time, I was very depressed, because it took a long time on the Sorting Algorithm, I forgot the sort method of Array.

But is the built-in sort method in javascript faster than the quick sorting algorithm?

Haha, I don't know after testing.

Let's talk about the environment I tested.

1. My testing environments are IE6.0 and firefox2.0.

2. There are many different implementation methods for each algorithm. In the following test, I chose the fast sorting algorithm implemented by the above netizens, But I just moved the embedded function out.

3. The algorithm execution speed is related to the data type, size, and data volume. Here I Only sort the data by an integer smaller than 999999. The data volume is set to 500, 2000, and 30000 respectively.

About the sort method: the sort method is a built-in method of Array: this is defined in the javascript authoritative guide:

The sort () method sorts the elements of array in place: no copy of the array is made. if sort () is called with no arguments, the elements of the array are arranged in alphabetical order (more precisely, the order determined by the character encoding ). to do this, elements are first converted to strings, if necessary, so that they can be compared.

If you want to sort the array elements in some other order, you must supply a comparison function that compares two values and returns a number indicating their relative order. the comparison function shocould take two arguments, a and B, and shoshould return one of the following:

The sort method can accept a function-type parameter to customize its own sorting logic. If no parameter is provided, it is sorted by character by default, therefore, you need to provide a function-type parameter for sorting integers. The call method in this test is as follows:

Array. sort (function (a, B) {return a-B })

Of course, if the numbers of Integers to be sorted are the same and the results returned by parameters are not provided, you can test the result as follows:

__Copy code__The Code is as follows:

<Script>

Alert ([3, 4, 5, 11, 1]. sort ())

Alert ([3, 4, 5, 11, 1]. sort (function (a, B) {return a-B }))

</Script>

Tip: you can modify it before running it.

The result is [1, 11, 3, 4, 5], which is obviously not the result we want.

Generates an array to be sorted. In order to obtain fair results, I randomly generate an array for sorting. The arrays used in each comparison have the same elements, the following code generates a random array:

__Copy code__The Code is as follows:

Function random (m, n ){

// Generate an integer between m and n

Var I = Math. random ();

Return Math. round (n-m) * I + m );

}

Function getRandomArr (m, n, l ){

// M: generate the minimum integer, n: generate the maximum integer, and l: the length of the generated Array

Var resultArr = [];

For (var I = 0; I <l; I ++ ){

ResultArr. push (random (m, n ))

}

Return resultArr;

}

The implementation of the quick sorting algorithm is based on the implementation of the netizen on the 51js forum that I saw. The Code is as follows:

__Copy code__The Code is as follows:

Function doSort (a, s, e)

{

If (s <e)

{

Var pos = partition (a, s, e );

DoSort (a, s, pos-1 );

DoSort (a, pos + 1, e );

}

}

Function partition (a, st, en)

{

Var s = st;

Var e = en + 1;

Var temp = a [s];

While (1)

{

While (a [++ s] <temp );

While (a [-- e]> temp );

If (s> e) break;

Var tem = a [s];

A [s] = a [e];

A [e] = tem;

}

A [st] = a [e];

A [e] = temp;

Return e;

}

Array. prototype. quickSort = function (){

DoSort (this, 0, this. length-1 );

}

Check whether the results are correctly determined using array. join (). The performance test code is as follows:

__Copy code__The Code is as follows:

Function sortIntF (a, B) {return a-B}

Function pk (num ){

// Num: number of elements in the array used for sorting

// Generate an array for sorting

Var arr = getRandomArr (1,999999, num );

// When the number of elements is less than 10000, the average value is obtained n times.

Var n = Math. ceil (10000/num );

// Generate multiple copies of the sorted Array

Var quickSortArrs = [];

Var sortArrs = [];

For (var I = 0; I <n; I ++ ){

QuickSortArrs. push (arr. slice (0 ));

SortArrs. push (arr. slice (0 ));

}

Var t1 = new Date ();

For (var I = 0; I <n; I ++ ){

QuickSortArrs [I]. quickSort ();

}

Var t2 = new Date ();

For (var I = 0; I <n; I ++ ){

SortArrs [I]. sort (sortIntF );

}

Var t3 = new Date ();

Alert ("performance comparison, for arrays of" + num + "elements, the average time consumed for each sort is as follows: \ n"

+ "Array. prototype. sort:" + (t3-t2)/n) + "ms \ n"

+ "QuickSort:" + (t2-t1)/n) + "ms \ n"

);

Alert ("Whether the sorting result is correct:" + (sortArrs [0]. join () = quickSortArrs [0]. join ()));

}

You can directly call the pk function. For example, if you want to compare the sorting performance of the array with 300 elements, you can call the pk (300) function.

The complete test code is as follows:

[Ctrl + A select all Note: If you need to introduce external Js, You need to refresh it to execute]

Test Results

First first time (MS)

500 elements: ie6.0: sort: 38.3 39.05 39.05

QuickSort: 8.6 8.6 9.4

Ff2.0: sort: 3.1 3.15 3.9

QuickSort: 4.7 4.7 3.15

2000 elements: ie6.0: sort: 200 203.2 203

QuickSort: 40.6 43.6 43.8

Ff2.0: sort: 18.8 18.6 18.8

QuickSort: 18.6 15.6 15.6

30000 elements: ie6.0: sort: 10360 9765 9203

QuickSort: 843 813 891

Ff2.0: sort: 422 422 406

QuickSort: 328 297 407

As you can see from the results,

In ie6.0, the fast sorting algorithm is much faster than the sort method of the Array object. for fewer elements, the fast sorting speed is about 5 times faster than that of the sort method, quick sorting of 30000 elements is dozens of times faster than the sort method.

In ff2.0, the speed of the two sort algorithms is almost the same, while that of the Quick sort Algorithm is slightly faster. This also shows that the sort of Array objects in ff2.0 is relatively efficient, maybe it is a quick sort, because it is very close to the data of the Quick Sort Algorithm

Note: The above tests only represent the test results on my local machine. The results may differ greatly from those on your machine. I hope you can also test them.