js实现常见的几种排序

//冒泡排序算法
            
            function  BubbleSort(array){
                var  n = array.length;
                var temp;
                 for(var i=0;i<n-1;i++){
                     for(var j=0;j<n-1-i;j++){
                          if(array[j]>array[j+1]){
                               temp = array[j+1];
                               array[j+1] = array[j];
                               array[j] = temp;
                          }
                     }
                 }
                 
                 return array;
            }
            
            
            //直接插入排序算法

将第一个元素默认为有序，然后依次将后面的数与前面已排好序的数组进行，然后将其插入正确的位置中去
            
            function  StraightInsertionSort(array){
                   for(var i=1;i<array.length;i++){
                         if(array[i]<array[i-1]){
                             var  temp = array[i];
                             for(var j=i-1;j>=0&&array[j]<temp;j--){
                                    array[j+1] = array[j]
                          }
                             array[j+1] = temp;
                         } 
                   }
                   
                   return array
            }
            
            //选择排序算法

从第一个开始，从后面的数里面选择最小的与当前的数交换，之后的数重复此操作
            
            
            function  SelectionSort(array){
                var min,temp,index;
                for(var i=0;i<array.length;i++){
                    var temp;
                    var index = i;
                    var min = array[i];
                    for(var j=i+1;j<array.length;j++){
                        if(temp>array[j]){
                            min = array[j];
                            index = j;
                        }
                    }
                    
                    temp = array[i];
                    array[i] = min;
                    array[index] = temp;
                }
                
                return array
            }
            
            
            
            //快速排序算法
            使用递归依次将数组分成包含最小和最大的
            function  QuickSort(array){
                
                if(array.length==0){
                    return []
                }
                var  temp=array[0];
                var   left=[],right=[];
                for(var i=1;i<array.length;i++){
                    if(array[i]>temp){
                        right.push(array[i]);
                    }else {
                        left.push(array[i])
                    }
                }
                return QuickSort(left).concat(temp,QuickSort(right));
            }
            
            //归并排序算法

依次将数组分成左右两组，形成一个二叉树，然后进行排序操作
            
            function  MergeSort(array){
                if(array.length<2){
                    return  array;
                }
                
                var  minddle = Math.floor(array.length/2);
                var left = array.slice(0,minddle);
                var right = array.slice(minddle);
                return  Merge(MergeSort(left),MergeSort(right));
            }
            
            function  Merge(left,right){
                var newarray=[];
                while(left.length&&right.length){
                    if(left[0]<=right[0]){
                        newarray.push(left.shift())
                    }else{
                        newarray.push(right.shift())
                    }
                }
                
                while(left.length){
                    newarray.push(left.shift())
                }
                while(right.length){
                    newarray.push(right.shift())
                }
                
                return newarray;
            }

//希尔排序算法

就是按间隔分组，直至间隔为零

//堆排序

先构建一个初始堆，然后选择大顶堆或是小顶堆，然后将堆顶元素末尾元素交换，将最大元素“沉”到数组末端，之后重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。

--------------------- 
作者：Coloryi 
来源：CSDN 
原文：https://blog.csdn.net/Coloryi/article/details/88082265 
版权声明：本文为博主原创文章，转载请附上博文链接！