测试几种排序算法的javascript实现及效能测试

用来排序对像数组的. 最后还是决定用Array对像的sort方法，尽管这些都没用上，还是自己记在空间里当笔记用的.

快速排序，优化的快速排序，忘了名子的排序方法，对像提供的排序;  绝对不要用起泡法，除非是教学生。

 

为了测试，写了一个生成随机对像的方法，用来生成一个对像，对像中有一个属性 a ，a 的值为一个随机数字.以下为生成Array的方法:

 

function getRandomStr(){ return Math.round((1000 - 1 + 1 ) * Math.random() + 1); } var arr = new Array(); for(var i=0;i<5000;i++){ arr.push({a:getRandomStr()}); }

 

方法零：

 

 

方法一

 

实现原理：

     遍历数组，取得其中最大值(最小值也可以)，将取到的值移到队列的最后，然后再次遍历至数组长度-1的位置，如此反复，直到最后需要遍历的位置长度为0 时为止，由于遍历次数只与数组长度有关，所以每次运行的次数是固定的. 即一个1 至 数组最大下标的累加值;

 

实现代码：

// 快速排序; function SortObject1(arr){ // 记录数组最后需要遍历的位置 var leavings = arr.length; // 准备交换对像用的临时变量; var p1 = arr[0],p=0,tmp; // 遍历数组; while(leavings != 0){ // 寻找数组中最大的值 for(var i=0;i < leavings;i++){ if(arr[i].a > p1.a){ p1 = arr[i]; p = i; } } //移动最大数据对像到队尾; leavings--; tmp = arr[p]; arr[p] = arr[leavings]; arr[leavings] = tmp; p1=arr[0],p=0; } }

 

方法二

 

实现原理：

    优化第一种算法，在寻找最大值的同时，寻找最小值，将最大值移动到队尾，将小值移动到队头，则于参与运算的数组长度每次-2 所以运行次数为 1  +3 +5 +7 +9 + (i)  , i<=Array.length

 

实现代码：(注释省了，跟上的一样，只是另一个if同时在找最小的值.)

function SortObject2(arr){ var leavings_e = arr.length; var leavings_s = 1 var p_max = arr[0],p_max_l=0,tmp; var p_min = arr[0],p_min_l=0,tmp; while(leavings_e > leavings_s){ for(var i=leavings_s;i<leavings_e;i++){ if(arr[i].a > p_max.a){ p_max = arr[i]; p_max_l = i; } if(arr[i].a < p_min.a){ p_min = arr[i]; p_min_l = i; } } leavings_e--; leavings_s++; tmp = arr[p_max_l]; arr[p_max_l] = arr[leavings_e]; arr[leavings_e] = tmp; p_max=arr[0],p_max_l=0; tmp = arr[p_min_l]; arr[p_min_l] = arr[leavings_s]; arr[leavings_s] = tmp; p_min=arr[0],p_min_l=0; } }

 

方法三

 

实现原理：

      以数组中的某一个元素的值为中间值，然后分别从前后同时遍历数组，将比它大的值扔在右边，比他小的值扔在左边（如果需要为倒序则将小的扔左边大的扔右边），然后以当前中间变量在数组中的位置为切点，将数组分成前后两个部份，再对每一部份重复操作，可以用递归，也可以用循环，如果数据量非常大担心堆栈溢出的话，可以使用循环，我使用50万长度数组测试，没有溢出问题；执行次数完全凭运气，但是在数据量大的时候，要比前两种方法高效很多倍。

 

实现代码：

function SortObject(S, En, arr) { var Start = S, End = En; var T = Start; // 记录中间量下标位置; while (true) { while (!(End <= Start)) { // 后面的移动到前面 if ((arr[T].a > arr[End].a)) { tmp = arr[T]; arr[T] = arr[End]; arr[End] = tmp; T = End; break; } End--; } // 将前面的移动到后面; while (!(End <= Start)) { if ((arr[T].a < arr[Start].a)) { tmp = arr[T]; arr[T] = arr[Start]; arr[Start] = tmp; T = Start; break; } Start++; } // 当到达中间变量位置时 if (End <= Start) break; } // 递归调用,排序前半段 if (T - S > 1) arr = SortObject(S, T - 1, arr); // 递归调用,排序后半段 if (En - T > 1) arr = SortObject(T + 1, En, arr); return arr; }

 

方法四：

javascript 提供的 Array.sort（Function） 方法;

var F_sort = function(a,b){ if(a.a>b.a){ return 1; }else if(a.a<b.a){ return -1; }else{ return 0; } }

 

 

 

测试方法：

分别排序内容相同的数组，数组长度分别为:10，100，500，1000，3000，5000，10000，个长度的数组；

测试结果(由于javascript 使用wscript 为执行宿主，所以无法精确测量毫秒值):

方法一： 10 长度数组 ，执行次数：55  执行时间(秒)：0
方法二： 10 长度数组 ，执行次数：25  执行时间(秒)：0
方法三： 10 长度数组 ，执行次数：37  执行时间(秒)：0

方法一： 100 长度数组 ，执行次数：5105  执行时间(秒)：0
方法二： 100 长度数组 ，执行次数：2525  执行时间(秒)：0
方法三： 100 长度数组 ，执行次数：927  执行时间(秒)：0

方法一： 500 长度数组 ，执行次数：130355  执行时间(秒)：0
方法二： 500 长度数组 ，执行次数：65025  执行时间(秒)：0
方法三： 500 长度数组 ，执行次数：7012  执行时间(秒)：0

方法一： 1000 长度数组 ，执行次数：630855  执行时间(秒)：1
方法二： 1000 长度数组 ，执行次数：315025  执行时间(秒)：0
方法三： 1000 长度数组 ，执行次数：21362  执行时间(秒)：0

 

方法一： 3000 长度数组 ，执行次数：4501500  执行时间(秒)：3
方法二： 3000 长度数组 ，执行次数：2250000  执行时间(秒)：3
方法三： 3000 长度数组 ，执行次数：55553  执行时间(秒)：1

 

方法一： 5000 长度数组 ，执行次数：12502500  执行时间(秒)：10
方法二： 5000 长度数组 ，执行次数：6250000  执行时间(秒)：9
方法三： 5000 长度数组 ，执行次数：95361  执行时间(秒)：1

 

方法一： 10000 长度数组 ，执行次数：50005000  执行时间(秒)：46
方法二： 10000 长度数组 ，执行次数：25000000  执行时间(秒)：39
方法三： 10000 长度数组 ，执行次数：222014  执行时间(秒)：0

 

长度再增长时，方法一与方法二运算时间太长，估不进行测试，转而进行javascript Array.sort 方法 与 方法三的测试;

分别进行 100 , 300 , 500 , 1000 , 1000 , 5000 , 10000,  50000, 100000, 次测试;

 

方法三： 100 长度数组 ，执行次数：805  执行时间(秒)：0
sort()： 100 长度数组 ，执行次数：1081  执行时间(秒)：0

方法三： 300 长度数组 ，执行次数：4115  执行时间(秒)：0
sort()： 300 长度数组 ，执行次数：5313  执行时间(秒)：0

方法三： 500 长度数组 ，执行次数：10256  执行时间(秒)：0
sort()： 500 长度数组 ，执行次数：13069  执行时间(秒)：0

方法三： 1000 长度数组 ，执行次数：25708  执行时间(秒)：0
sort()： 1000 长度数组 ，执行次数：30652  执行时间(秒)：0

 

方法三： 1000 长度数组 ，执行次数：14864  执行时间(秒)：0
sort()： 1000 长度数组 ，执行次数：17583  执行时间(秒)：0

方法三： 5000 长度数组 ，执行次数：112403  执行时间(秒)：1
sort()： 5000 长度数组 ，执行次数：129709  执行时间(秒)：0

方法三： 10000 长度数组 ，执行次数：333592  执行时间(秒)：0
sort()： 10000 长度数组 ，执行次数：374169  执行时间(秒)：1

方法三： 50000 长度数组 ，执行次数：2304399  执行时间(秒)：2
sort()： 50000 长度数组 ，执行次数：1829607  执行时间(秒)：4

方法三： 100000 长度数组 ，执行次数：8268002  执行时间(秒)：8
sort()： 100000 长度数组 ，执行次数：4942124  执行时间(秒)：7

 

方法三： 200000 长度数组 ，执行次数：20428153  执行时间(秒)：27
sort()： 200000 长度数组 ，执行次数：6626912  执行时间(秒)：16

方法三： 300000 长度数组 ，执行次数：63212029  执行时间(秒)：54
sort()： 300000 长度数组 ，执行次数：16906661  执行时间(秒)：24

 

 

当处理数据量小于3000时，可以使用以上任意排序方法，结果对用户意义不大，当数据达到3000以上时，可以使用后两种，当数据为十万条时，方法三与sort方法的执行结果相当，但是处理更大的数据时，sort方法明显更多的节少了时间与运算次数。

 

结论，除了学习制造轮子以外，请使用以有的轮子。而不要重复发明轮子，除非你发明的轮子不是圆的并且能飞；