JavaScript版几种常见排序算法分享

说明

·  每个浏览器测试得出的数据会不一样。比如我用chrome 测试 一般快速排序都会最快，IE 则根据数组长度有可能希尔最快。

·  不要用太大数据去测试冒泡排序(浏览器崩溃了我不管)

个人理解

·  冒泡排序：最简单，也最慢，貌似长度小于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, len = array.length,  
11.             j, d;  
12.         for(; i<len; i++){  
13.             for(j=0; j<len; j++){  
14.                 if(array[i] < array[j]){  
15.                     d = array[j];  
16.                     array[j] = array[i];  
17.                     array[i] = d;  
18.                 }  
19.             }  
20.         }  
21.         return array;  
22.     },  
23.     // 快速排序  
24.     quickSort:function(array){  
25.         //var array = [8,4,6,2,7,9,3,5,74,5];  
26.         //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];  
27.         var i = 0;  
28.         var j = array.length - 1;  
29.         var Sort = function(i, j){  
30.               
31.             // 结束条件  
32.             if(i == j ){ return };  
33.               
34.             var key = array[i];  
35.             var tempi = i; // 记录开始位置  
36.             var tempj = j; // 记录结束位置  
37.               
38.             while(j > i){  
39.                 // j <<-------------- 向前查找  
40.                 if(array[j] >= key){  
41.                     j--;  
42.                 }else{  
43.                     array[i] = array[j]  
44.                     //i++ ------------>>向后查找  
45.                     while(j > ++i){  
46.                         if(array[i] > key){  
47.                             array[j] = array[i];  
48.                             break;  
49.                         }  
50.                     }  
51.                 }  
52.             }  
53.               
54.             // 如果第一个取出的 key 是最小的数  
55.             if(tempi == i){  
56.                 Sort(++i, tempj);  
57.                 return ;  
58.             }  
59.               
60.             // 最后一个空位留给 key  
61.             array[i] = key;  
62.               
63.             // 递归  
64.             Sort(tempi, i);  
65.             Sort(j, tempj);  
66.         }  
67.           
68.         Sort(i, j);  
69.           
70.         return array;  
71.     },  
72.       
73.     // 插入排序  
74.     insertSort:function(array){  
75.           
76.         // http://baike.baidu.com/image/d57e99942da24e5dd21b7080  
77.         // http://baike.baidu.com/view/396887.htm  
78.         //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];  
79.           
80.         var i = 1, j, temp, key,  
81.             len = array.length;  
82.           
83.         for(; i < len; i++){  
84.               
85.             temp = 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.           
109.         var tempArr = [1750, 701, 301, 132, 57, 23, 10, 4, 1];   
110. // reverse() 在维基上看到这个最优的步长 较小数组  
111.         //var tempArr = [1031612713, 217378076, 45806244,   
112. 9651787, 2034035, 428481, 90358, 19001, 4025, 836, 182, 34, 9, 1]  
113. //针对大数组的步长选择  
114.         var i = 0;  
115.         var tempArrtempArrLength = tempArr.length;  
116.         var len = array.length;  
117.         var len2 =  parseInt(len/2);  
118.           
119.         for(;i < tempArrLength; i++){  
120.             if(tempArr[i] > len2){  
121.                 continue;  
122.             }  
123.               
124.             tempSort(tempArr[i]);  
125.         }  
126.  
127.         // 排序一个步长  
128.         function tempSort(temp){  
129.               
130.             //console.log(temp) 使用的步长统计  
131.               
132.             var i = 0, j = 0, f, tem, key;  
133.             var tempLen = len%temp > 0 ?  parseInt(len/temp) + 1 : len/temp;   
134.               
135.               
136.             for(;i < temp; i++){// 依次循环列  
137.  
138.                 for(j=1;/*j < tempLen && */temp * j + i < len; j++){
     //依次循环每列的每行  
139.                     tem = f = temp * j + i;  
140.                     key = array[f];  
141.  
142.                     while((tem-=temp) >= 0){  
143. // 依次向上查找  
144.                         if(array[tem] > key){  
145.                             array[tem+temp] = array[tem];  
146.                         }else{  
147.                             break;  
148.                         }  
149.                     }  
150.                       
151.                     array[tem + temp ] = key;  
152.                       
153.                 }  
154.             }  
155.               
156.         }  
157.           
158.         return array;  
159.           
160.     } 

原文链接：http://www.cnblogs.com/idche/archive/2011/02/16/1956397.html

【编辑推荐】

1. 10个令人惊奇的HTML5和JavaScript效果
2. JavaScript对象及继承教程之内置对象
3. JavaScript内存回收机制深入解读
4. JavaScript初学者应注意的七个细节
5. 写了10年Javascript未必全了解的连续赋值运算

【责任编辑：陈贻新 TEL：（010）68476606】

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索数组
， 分数步长法
， 排序
， 希尔排序
， function
， array
， var
， 快速
， javascript冒泡排序
， 冒泡排序和sort
， JavaScript快速排序
， js快速排序
， js冒泡排序
JS插入排序
javascript排序算法、常见排序算法、常见的排序算法、java常见排序算法、几种常见的排序算法，以便于您获取更多的相关知识。