js排序算法

1.选择排序

var sort_choose = function (arr) {
  for(var i = 0;i<arr.length-1; i++){
            var pos = i;
            for(var j = i+1;j<arr.length; j++){
                if(arr[pos] > arr[j]){
                    pos = j;
                }
            }
            arr = swap(arr,i,pos);
        }
        return arr;
};

选择排序在每个循环时都需比较剩余所有元素，因此效率不高
时间复杂度不管是最坏还是平均都为O(n^2)

2.插入排序

function sortInsert(arr) {
    var sArr = arr.slice(0);
    for (var i = 1; i < sArr.length; i++) {
        var temp = sArr[i];
        for (var j = i; j > 0 && temp < sArr[j - 1]; j--) {
            sArr[j] = sArr[j - 1];
        }
        sArr[j] = temp;
    }
    return sArr;
}

插入排序中，当不符和条件时，退出循环，而不是比较所有剩余元素
当排序的数组中元素接近有序时，插入排序效率较高，时间复杂度接近O(n)
时间复杂度不管是最坏还是平均都为O(n^2)

4.归并排序

var sort_merge = function (arr) {
    if(arr.length < 2) {
        return arr;
    }
    var step,right,left;
    step = 1;
    while(step < arr.length){
        left = 0;
        right = step;
        while(right + step <= arr.length){
            mergeArrays(arr,left,left+step,right,right+step);
            left = right + step;
            right = left + step;
        }
        if(right < arr.length){
            mergeArrays(arr,left,left+step,right,arr.length);
        }
        step *= 2;
    }
    return arr;
};
var mergeArrays = function (arr,startLeft,stopLeft,startRight,stopRight) {
    var rightArr = new Array(stopRight - startRight);
    var leftArr = new Array(stopLeft - startLeft);
    var k = startLeft,m,n;
    m = n = 0;
    for(var i = 0;i < leftArr.length; i++){
        leftArr[i] = arr[k++];
    }
    k = startRight;
    for(var j = 0;j < rightArr.length; j++){
        rightArr[j] = arr[k++];
    }
    while(m < leftArr.length && n < rightArr.length){
        if(leftArr[m] <= rightArr[n]){
            arr[startLeft++] = leftArr[m++];
        }else{
            arr[startLeft++] = rightArr[n++];
        }
    }
    if(m < leftArr.length){
        for(var t = m; t<leftArr.length; t++){
            arr[startLeft++] = leftArr[t];
        }
    }else if(n < rightArr.length){
        for(var t1 = n; t1<rightArr.length; t1++){
            arr[startLeft++] = rightArr[t1];
        }
    }
};

归并排序也是进行递归，时间复杂度均为O(nlogn)
优化：若两组待归并的数组A和B，A 的最后一个元素小于B的第一个元素时，则不需要归并，因为已经是排好序的。

4.快速排序

var sort_quik = function (arr,left,right) {
    if(left < right){
        var pos = change_quik(arr,left,right);
        sort_quik(arr,left,pos);
        sort_quik(arr,pos+1,right);
    }
    return arr;
};
var change_quik = function (arr,left,right) {
    var pos = left;
    var temp = arr[left];
    for(var i = left+1 ;i < right; i++){
        if(arr[i]<temp){
            pos++;
            swap(arr,pos,i);
        }
    }
    arr[left] = arr[pos];
    arr[pos] = temp;
    return pos;
};

• 快速排序，若数组是随机的，平均时间复杂度为O(nlogn)，因为递归树的高度为nlogn
• 当数组接近有序且以第一个数为基准时，递归树的高度接近n,因此，最坏情况下快速排序时间复杂度为n^2
• 可随机取一个数为基准进行排序，第一此取到最小数的概率为1/n，第二次为1/(n-1)；当n越大时，每次取到最小数的概率几乎为0，因此快排的时间复杂度为n^2的几率很低