js常见排序算法

Posted 2020-10-11

常见的有冒泡排序、选择排序、归并排序、快排、希尔排序、插入排序等 等 

　

 1 var arr=[1,2,3,6,5,4,7,9,8];
 2         /*冒泡排序*/
 3         /*相当于是对数组进行循环，相邻的两个进行比较，如果后面的比前面的小，调换位置，始初保持两个数后面的是值较大的，这样排到最后，最大的值会被调换至末尾，依次类推，完成排序*/
 4         function bubbleSrot(arr) {
 5             for(var i=0;i<arr.length;i++){
 6                 for(var j=0;j<arr.length-1;j++){ /*这里的lenght-1是设置把排序进行到第几位，因为最后一位已经确定，所以省略最后一个*/
 7                     if( arr[j+1] < arr[j]){
 8                         temp = arr[j+1];
 9                         arr[j+1] = arr[j];
10                         arr[j] = temp;
11                     }
12                 }
13             }
14             return arr;
15         }
16 //        console.log(‘bubbleSort: ‘+bubbleSrot(arr));    /*[1, 2, 3, 4, 5, 6, 7, 8, 9]*/
17 
18 
19         /*选择排序*/
20         /*相当于是从数组中循环，从循环的范围内找出最小的，与第一个比较，如果比第一个小调换位置，如下面代码中，当i=0的时候，相当于第一次循环，所以在数组的第二个到最后一个范围中选出一个最小的，与第一个比较，进行是否调换 ，依此类推，进行数组排序*/
21         function selectionSort (arr){
22             var len = arr.length;
23             for(var i=0;i<len;i++){
24                 var min = arr[i];   /*假设第一个值为数组中最小值*/
25                 var index = i;  /*最小值的下标*/
26                 for(var j= i+1;j<len;j++){  /*从数组下标为1的值开始比较*/
27                     if (arr[j] < min) {     /*比较获取最小值，如果下一个值比min小的话，把值赋给min,并把下标赋值给*/
28                         min = arr[j];
29                         index = j;
30                     }
31                 }
32                 if(index != i){     /*如果第范围内第一个值不是最小的，把它与最小的调换位置*/
33                     var temp = arr[i];
34                     arr[i] = arr[index];
35                     arr[index] = temp;
36                 }
37             }
38             return arr;
39         }
40 //        console.log(‘selectionSort:‘+selectionSort(arr));   /*[1, 2, 3, 4, 5, 6, 7, 8, 9]*/
41 
42         /*归并排序*/
43         /*所一个数组分为两个数组，先排好左边，再排好右边，然后把两个合并到一起*/
44         function mergeSort(arr,s,e){
45             if(s>e){   //起始位置大于终点位置，返回空数组
46                 return [];
47             }else if(s==e){
48                 return [arr[s]]; //起始位置等于终点位置，说明数组里只有一个数字，返回只含一个数字的数组
49             }
50 
51             var mIndex = Math.floor((s+e)/2); //中间位置的Index
52             var arrL = mergeSort(arr,s,mIndex); //将左边的数组排序
53             var arrR = mergeSort(arr,mIndex+1,e); //将右边的数组排序
54 
55             var resultArr = []; //结果数组
56             while(arrL.length>0 || arrR.length>0){ //当左右两个数组都不为空时
57                 if(arrL[0]<arrR[0]){
58                     resultArr.push(arrL.shift());
59                 }else{
60                     resultArr.push(arrR.shift());
61                 }
62 
63                 if(arrL.length==0){  //当左边的数组为空时
64                     resultArr = resultArr.concat(arrR);
65                     break;
66                 }else if(arrR.length==0){
67                     resultArr = resultArr.concat(arrL);
68                     break;
69                 }
70             }
71             return resultArr;
72         }
73 
74 //        console.log(mergeSort(arr,0,arr.length-1));
75 
76         /*快速排序*/
77         /*从数组中选一个元素作为标准，大于这个数的放到它的右边，小于这个数的放到它的左边，依此类推，直到只剩下一个元素，排序完成*/
78         function quickSort (arr) {
79             if (arr.length <= 1) {
80                 return arr;
81             }
82             var mNumIndex = Math.floor(arr.length/2);  /*设置基数index*/
83             var mNum = arr.splice([mNumIndex],1)[0];     /*获取基数值*/
84             var left = [];
85             var right = [];
86 
87             for(var i=0;i<arr.length;i++){
88                 if(arr[i]<mNum) {
89                     left.push(arr[i]);
90                 } else {
91                     right.push(arr[i]);
92                 }
93             }
94             return quickSort(left).concat([mNum],quickSort(right));
95         }
96 //        console.log(quickSort(arr));