排序算法总结一（JavaScript）

1、冒泡排序

基本思想：外层循环遍历数组，内层循环进行冒泡操作。

复杂度：O（n2）           稳定

function bubbleSort(arr){
    var n=arr.length;
    for(var i=0;i<n;i++){
        for(var j=n-1;j>i;j--){
            if(arr[j]<arr[j-1]){
                var temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }
        }
    }
    return arr;
}

2、选择排序

基本思想：从第一个元素开始遍历数组，从当前元素之后的元素中选出最小的，与当前元素交换.。

复杂度： O（n2）         不稳定

function selectSort(arr){
    var n=arr.length;
    for(var i=0;i<n-1;i++){
        var minIndex=i;
        //选择i~n中最小的
     //循环必须进行完
     for(var j=i+1;j<n;j++){
            if(arr[j]<arr[minIndex]){
                minIndex=j;
            }
        }
        //将最小的与arr[i]交换
     var temp=arr[i];
        arr[i]=arr[minIndex];
        arr[minIndex]=temp;
    }
    return arr;
}

3、插入排序

基本思想：从第二个元素开始遍历数组，先存放当前元素的副本，将副本与前面排好序的元素一一比较，找出合适的位置，将副本插入。

复杂度： O（n2）         稳定

与选择排序相比，优点是可以提前终止内层循环，当数组近乎有序时时间复杂度非常小，完全有序时为O（n）

function insertSort(arr){
    var n=arr.length;
    // 从第二个元素开始比较  第一个元素不需要插入
    for(var i=1;i<n;i++){
        //存放arr[i]的副本
     var t=arr[i];
        var j;
        //循环可以提前终止（即j不一定减到1），只要arr[j-1]<t就可以终止
     for(j=i;j>0&&arr[j-1]>t;j--){
            arr[j]=arr[j-1];
        }
        arr[j]=t;
    }
    return arr;
}

4、希尔排序

基本思想：先将待排序元素分割成若干个子序列（由相隔gap的若干个元素组成），对每个子序列进行直接插入排序，缩减gap的值再进行排序，待整个数组基本有序时（gap足够小），再对所有元素进行一次插入排序。

复杂度： O（n1.3）         不稳定

插入排序在书序几近有序的情况下效率很高，因此希尔排序在时间效率上有很大提高。

function shellSort(arr){
    var gap,i,j,temp;
    var n=arr.length;
    for (gap = n/2; gap > 0; gap=Math.floor(gap/ 2))
    {
        for(i = gap; i < n; i++)
            for(j = i-gap; j>=0 && arr[j]>arr[j+gap]; j -= gap)
            {
                temp = arr[j];
                arr[j] = arr[j+gap];
                arr[j+gap] = temp;
            }
    }
    return arr;

}