排序算法总结二（JavaScript）

1、归并排序（自顶向下）

复杂度： O（nlogn）               稳定

保留副本需要开辟额外n个存储空间，以空间换取时间效率

//将左右两部分数组进行归并，保留原数组的一个副本，一个一个比较左右两个部分数组元素的大小，将副本的相应元素放到数组中
function __merge(arr,l,mid,r){
    var copy=[];
    for(var m=l;m<=r;m++){
        copy[m]=arr[m];
    }
    var i=l,j=mid+1;
    for(var k=l;k<=r;k++){
        if(i>mid){              //左边部分已完成归并
            arr[k]=copy[j];
            j++;
        }
        else if(j>r){          // 右边部分已完成归并
            arr[k]=copy[i];
            i++;
        }
        else if(copy[i]<copy[j]){     //左边部分的元素大，将该元素添加到数组中，左边索引 i 右移
            arr[k]=copy[i];
            i++;
        }
        else{
            arr[k]=copy[j];      //右边部分的元素大，将该元素添加到数组中，右边索引 j 右移

            j++;
        }
    }

}

//递归调用归并排序函数对整个数组进行排序
function __mergeSort(arr,l,r){
    if(l>=r){
        return;
    }
    var mid=Math.floor((l+r)/2);
    __mergeSort(arr,l,mid);
    __mergeSort(arr,mid+1,r);
    //若左边最大值比右边最小值大，则进行归并操作，否则表示两部分已有序，不需要再进行归并   
  if(arr[mid]>arr[mid+1]){
        __merge(arr,l,mid,r);
    }
}
function mergeSort(arr){
    var n=arr.length;
    __mergeSort(arr,0,n-1);
    return arr;
}

2、归并排序（自底向上）

function __merge(arr,l,mid,r){
    var copy=[];
    for(var m=l;m<=r;m++){
        copy[m]=arr[m];
    }
    var i=l,j=mid+1;
    for(var k=l;k<=r;k++){
        if(i>mid){
            arr[k]=copy[j];
            j++;
        }
        else if(j>r){
            arr[k]=copy[i];
            i++;
        }
        else if(copy[i]<copy[j]){
            arr[k]=copy[i];
            i++;
        }
        else{
            arr[k]=copy[j];
            j++;
        }
    }

}
//若不进行优化  则可以用来对链表进行排序，因为排序中没有用到数组的下标
function mergeSortBU(arr){
    var n=arr.length;
    var size,i;
    //分轮次进行归并，每轮归并的元素数量为size
    for(size=1;size<n;size+=size){
        //每轮归并分组进行
        for(i=0;i+size<n;i+=size+size){
            //优化：如果两边已经有序就不在进行归并
            if(arr[i+size-1]>arr[i+size]){
                __merge(arr,i,i+size-1,Math.min(i+size+size-1,n-1));   //防止越界
            }
        }
    }
    return arr;
}

3、快速排序（三路快排序）

复杂度： O（nlogn）           不稳定

不需要开辟额外空间

function __quickSort(arr,l,r){
    if(l>=r){
        return;
    }
    //三路： 分为三部分  比参考元素小：arr[l+1....lt] 等于参考元素： arr[lt+1....i] 大于参考元素： arr[gt...r];
    var v=arr[l];     //取第一个元素为参考
    var lt=l;
    var gt=r+1;
    var i=l+1;
    while(i<gt){
        if(arr[i]<v){        //比参考元素小的与lt+1交换
            var temp=arr[i]; arr[i]=arr[lt+1]; arr[lt+1]=temp;
            lt++;
            i++;
        }
        else if(arr[i]>v){     //比参考元素大的与gt-1交换
            var temp2=arr[i]; arr[i]=arr[gt-1]; arr[gt-1]=temp2;
            gt--;
        }
        else{           //与参考元素相等直接右移
            i++;
        }
    }
    //将参考元素放到合适的位置
    var temp1=arr[l];
    arr[l]=arr[lt];
    arr[lt]=temp1;
    //递归对左右两部分进行快排序
    __quickSort(arr,l,lt-1);
    __quickSort(arr,gt,r);
}
function quickSort(arr){
    var n=arr.length;
    __quickSort(arr,0,n-1);
    return arr;
}

4、堆排序

复杂度： O（nlogn）         不稳定

原地堆排序，不需要开辟额外空间

//left child (i)=2*i+1      right child (i)=2*i+2     parent(i)=(i-1)/2
//最后一个非叶子节点的索引： (n-1)/2
//构建最大堆的函数
function shiftDown(arr,n,k){
    //要保证左孩子在n范围内   并且该节点比其左孩子或右孩子中任意一个小
    while((2*k+1)<n && (arr[k]<arr[2*k+1] || (arr[k]<arr[2*k+2]&&2*k+2<n))){
        //有右孩子且右孩子比左孩子大
        if(2*k+2<n&&arr[2*k+1]<arr[2*k+2]){
            [arr[k],arr[2*k+2]]=[arr[2*k+2],arr[k]];
            k=2*k+2;
        }else{            //包含右孩子比左孩子小和没有右孩子两种情况
            [arr[k],arr[2*k+1]]=[arr[2*k+1],arr[k]];
            k=2*k+1;
        }
    }
}
function heapSort(arr){
    var n=arr.length;
    //将数组构建成最大堆
    for(var i=Math.floor((n-1)/2);i>=0;i--){
        shiftDown(arr,n,i);
    }
    for(var j=n-1;j>0;j--){
        //堆顶元素最大，每次将堆顶元素与最后一个元素交换
        [arr[j],arr[0]]=[arr[0],arr[j]];
        //如果待排序元素数大于1，则进行堆重构；等于1说明已经完成排序
        if(j>1){
            shiftDown(arr,j,0);
        }else{
            break;
        }
    }
    return arr;
}