JavaScript版几种常见排序算法

今天发现一篇文章讲“JavaScript版几种常见排序算法”，看着不错，推荐一下原文：http://www.w3cfuns.com/blog-5456021-5404137.html

算法描述：

* 冒泡排序：最简单，也最慢，貌似长度小于7最优
* 插入排序： 比冒泡快，比快速排序和希尔排序慢，较小数据有优势
* 快速排序：这是一个非常快的排序方式，V8的sort方法就使用快速排序和插入排序的结合
* 希尔排序：在非chrome下数组长度小于1000，希尔排序比快速更快
* 系统方法：在forfox下系统的这个方法非常快

  1 // ---------- 一些排序算法
  2 // js 利用sort进行排序
  3 systemSort: function(array) {
  4     return array.sort(function(a, b) {
  5         return a - b;
  6     });
  7 },
  8 // 冒泡排序
  9 bubbleSort: function(array) {
 10     var i = 0,
 11     len = array.length,
 12     j, d;
 13     for (; i < len; i++) {
 14         for (j = 0; j < len; j++) {
 15             if (array[i] < array[j]) {
 16                 d = array[j];
 17                 array[j] = array[i];
 18                 array[i] = d;
 19             }
 20         }
 21     }
 22     return array;
 23 },
 24 // 快速排序
 25 quickSort: function(array) {
 26     //var array = [8,4,6,2,7,9,3,5,74,5];
 27     //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];
 28     var i = 0;
 29     var j = array.length - 1;
 30     var Sort = function(i, j) {
 31
 32         // 结束条件
 33         if (i == j) {
 34             return
 35         };
 36
 37         var key = array[i];
 38         var stepi = i; // 记录开始位置
 39         var stepj = j; // 记录结束位置
 40         while (j > i) {
 41             // j <<-------------- 向前查找
 42             if (array[j] >= key) {
 43                 j--;
 44             } else {
 45                 array[i] = array[j]
 46                 //i++ ------------>>向后查找
 47                 while (j > ++i) {
 48                     if (array[i] > key) {
 49                         array[j] = array[i];
 50                         break;
 51                     }
 52                 }
 53             }
 54         }
 55
 56         // 如果第一个取出的 key 是最小的数
 57         if (stepi == i) {
 58             Sort(++i, stepj);
 59             return;
 60         }
 61
 62         // 最后一个空位留给 key
 63         array[i] = key;
 64
 65         // 递归        Sort(stepi, i);
 66         Sort(j, stepj);
 67     }
 68
 69     Sort(i, j);
 70
 71     return array;
 72 },
 73
 74 // 插入排序
 75 insertSort: function(array) {
 76
 77     // http://baike.baidu.com/image/d57e99942da24e5dd21b7080
 78     // http://baike.baidu.com/view/396887.htm
 79     //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];
 80     var i = 1,
 81     j, step, key, len = array.length;
 82
 83     for (; i < len; i++) {
 84
 85         step = j = i;
 86         key = array[j];
 87
 88         while (--j > -1) {
 89             if (array[j] > key) {
 90                 array[j + 1] = array[j];
 91             } else {
 92                 break;
 93             }
 94         }
 95
 96         array[j + 1] = key;
 97     }
 98
 99     return array;
100 },
101
102 // 希尔排序
103 //Jun.array.shellSort(Jun.array.df(10000));
104 shellSort: function(array) {
105
106     // http://zh.wikipedia.org/zh/%E5%B8%8C%E5%B0%94%E6%8E%92%E5%BA%8F
107     // var array = [13,14,94,33,82,25,59,94,65,23,45,27,73,25,39,10];
108     var stepArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1]; // reverse() 在维基上看到这个最优的步长 较小数组
109     //var stepArr = [1031612713, 217378076, 45806244, 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1]//针对大数组的步长选择
110     var i = 0;
111     var stepArrLength = stepArr.length;
112     var len = array.length;
113     var len2 = parseInt(len / 2);
114
115     for (; i < stepArrLength; i++) {
116         if (stepArr[i] > len2) {
117             continue;
118         }
119
120         stepSort(stepArr[i]);
121     }
122
123     // 排序一个步长
124     function stepSort(step) {
125
126         //console.log(step) 使用的步长统计
127         var i = 0,
128         j = 0,
129         f, tem, key;
130         var stepLen = len % step > 0 ? parseInt(len / step) + 1 : len / step;
131
132         for (; i < step; i++) { // 依次循环列
133             for (j = 1;
134             /*j < stepLen && */
135             step * j + i < len; j++) { //依次循环每列的每行
136                 tem = f = step * j + i;
137                 key = array[f];
138
139                 while ((tem -= step) >= 0) { // 依次向上查找
140                     if (array[tem] > key) {
141                         array[tem + step] = array[tem];
142                     } else {
143                         break;
144                     }
145                 }
146
147                 array[tem + step] = key;
148
149             }
150         }
151
152     }
153
154     return array;
155
156 }