js中各个排序算法和sort函数的比较

js中要实现数据排序，其实只需要用sort函数就能很好的满足了，但是我今天想知道他和其他排序算法的区别，比如耗时呀等。测了一组数据如下：

 // ---------- 一些排序算法
 Sort = {}
 Sort.prototype = {
       // 利用sort进行排序
        systemSort:function(array){
           return array.sort(function(a, b){
               return a - b;
           });
       },
       // 冒泡排序
       bubbleSort:function(array){
           var i = 0, len = array.length,
               j, d;
           for(; i<len; i++){
               for(j=0; j<len; j++){
                   if(array[i] < array[j]){
                       d = array[j];
                       array[j] = array[i];
                       array[i] = d;
                   }
               }
           }
           return array;
       },
       // 快速排序
       quickSort:function(array){
           //var array = [8,4,6,2,7,9,3,5,74,5];
           //var array =[0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7];
           var i = 0;
           var j = array.length - 1;
           var Sort = function(i, j){
               // 结束条件
               if(i == j ){ return };
               var key = array[i];
               var tempi = i; // 记录开始位置
               var tempj = j; // 记录结束位置  

               while(j > i){
                   // j <<-------------- 向前查找
                   if(array[j] >= key){
                       j--;
                   }else{
                       array[i] = array[j]
                       //i++ ------------>>向后查找
                       while(j > ++i){
                           if(array[i] > key){
                               array[j] = array[i];
                               break;
                           }
                       }
                   }
               }
               // 如果第一个取出的 key 是最小的数
               if(tempi == i){
                   Sort(++i, tempj);
                   return ;
               }
               // 最后一个空位留给 key
               array[i] = key;
               // 递归
               Sort(tempi, i);
               Sort(j, tempj);
           }
           Sort(i, j);
           return array;
       },
       // 插入排序
       insertSort:function(array){
           // http://baike.baidu.com/image/d57e99942da24e5dd21b7080
           // http://baike.baidu.com/view/396887.htm
           // var array = [0,1,2,44,4,324,5,65,6,6,34,4,5,6,2,43,5,6,62,43,5,1,4,51,56,76,7,7,2,1,45,4,6,7];
           var i = 1, j, temp, key, len = array.length;
           for(; i < len; i++){
               temp = j = i;
               key = array[j];
               while(--j > -1){
                   if(array[j] > key){
                       array[j+1] = array[j];
                   }else{
                       break;
                   }
               }
               array[j+1] = key;
           }
           return array;
       },  

       // 希尔排序
       //Jun.array.shellSort(Jun.array.df(10000));
       shellSort:function(array){
           // http://zh.wikipedia.org/zh/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F
           // var array = [13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10];
           // var tempArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1];
           // reverse() 在维基上看到这个最优的步长 较小数组
           var tempArr = [1031612713, 217378076, 45806244, 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1]
               //针对大数组的步长选择
           var i = 0;
           var tempArrLength = tempArr.length;
           var len = array.length;
           var len2 =  parseInt(len/2);  

           for(;i < tempArrLength; i++){
               if(tempArr[i] > len2){
                   continue;
               }
               tempSort(tempArr[i]);
           }
           // 排序一个步长
           function tempSort(temp){
               //console.log(temp) 使用的步长统计
               var i = 0, j = 0, f, tem, key;
               var tempLen = len%temp > 0 ?  parseInt(len/temp) + 1 : len/temp;
               for(;i < temp; i++){// 依次循环列
                   for(j=1;/*j < tempLen && */temp * j + i < len; j++){
                         //依次循环每列的每行
                       tem = f = temp * j + i;
                       key = array[f];
                       while((tem-=temp) >= 0){
                             // 依次向上查找
                           if(array[tem] > key){
                               array[tem+temp] = array[tem];
                           }else{
                               break;
                           }
                       }
                       array[tem + temp ] = key;
                   }
               }
           }
           return array;
       }
 }
 testArrs = [];
 for (var i = 0; i < 5000; i++) {
   testArrs.push(Math.random());
 };
 console.log(+new Date());
 Sort.prototype.systemSort(testArrs);
 console.log(+new Date());
 Sort.prototype.bubbleSort(testArrs);
 console.log(+new Date());
 Sort.prototype.quickSort(testArrs);
 console.log(+new Date());
 ss = Sort.prototype.insertSort(testArrs);
 //console.log(ss.toString);
 console.log(+new Date());
 oo = Sort.prototype.shellSort(testArrs);
 console.log(+new Date());
 //console.log(oo.toString());

打印的数据如下：

1390474099605

1390474099614

1390474099720

1390474099759

1390474099760

1390474099761

可以看出，冒泡排序耗时最高106，耗时最少的是插入排序，希尔排序也不错，sort函数的排序时间9，相比起来和插入排序差别不是很大，所以在js中用sort来实现排序，在要求不是很高的情况下都是ok的。