常用排序算法汇总js版

//冒泡排序
//比较前后两个，若前一个比后一个大，则交换位置

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

//改进后的冒泡排序
function ModifybubbleSort(array) {
    var length=array.length;
    for(var i = 0;i<length;i++){
        for(var j = 0;j< length - 1;j++){
            if(array[j]>array[j + 1]){
                var temp=array[j];
                array[j]=array[j + 1];
                array[j+1]=temp;
            }
        }
    }
    return array;
}

//选择排序
//思想：循环整个数组，先选择出最小的放在一项，后选择第二小的，以此类推。。
var selectionSort=function(array){
    var length=array.length,min;
    for(var i = 0;i<length-1;i++){
        min=i;
        for(var j = i;j<length;j++){
            if(array[min]>array[j]){
               min=j;
            }
        }
        if(min!==i){
            var temp=array[min];
            array[min]=array[i];
            array[i]=temp;
        }
    }
    return array;
};

//插入排序
//思想:假定第一项排序了,检查第二项与第一项的关系，若比第一项小，第二项插入第一项前面，后比较第三项和前两项关系，进行插入排序
var insertSort=function (array) {
    var length=array.length,
        temp,j;
    for(var i = 1;i<length;i++){
        j=i;
        temp = array[i];
        while(j>0&&array[j-1]>temp){
            array[j] =array[j-1];
            j--;
        }
        array[j]=temp;
    }
};

//归并排序
//思想：现将数组划分为较小的数组，直到每个小组只有一个位置，后将小数组归并成较大的数组，直到最后只有一个排序完成的大数组
var mergeSort=function (array) {
    var length = array.length;
    if(length<=1){
        return array;
    }
    var mid =Math.floor(array.length/2),
        left=array.slice(0,mid);
        right = array.slice(mid,length);
    return merge(mergeSort(left),mergeSort(right));
};
var merge = function (left,right) {
    var result = [],
        il=0,ir=0;
    while(il<left.length&&ir<right.length){
        if(left[ir]<right[il]){
            result.push(left[il++]);
        }else{
            result.push(right[ir++]);
        }
    }
    while(il<left.length){
        result.push(left[il++]);
    }
    while(ir<right.length){
        result.push(right[ir++]);
    }
    return result;
};

//快速排序
//思想：(1)将中间的一项选择为主元，创建两个指针，左边指向数组第一项，右边指向数组最后一项，移动左指针找到一个比它大的元素，后移动右指针找到一个比它小的元素，然后交换，后重复这个过程
//直到比主元大的都在主元之后，比它小的都在主元之前。接着，算法对划分的数组重复之前的操作，直至数组完全合并。
var quickSort=function (array) {
    quick(array,0,array.length-1);
};
function quick(array,left,right) {
    var index;
    if(array.length>1){
        index = partition(array,left,right);
        if(left<index-1){
            quick(array,left,index-1);
        }
        if(index-1<right){
            quick(array,index,right);
        }
    }
}
var partition=function (array,left,right) {
    var pivot=array[Math.floor((left+right)/2)],
        i = left,
        j = right;
    while(i<j){
        while(array[i]<pivot){
            i++;
        }
        while(array[j]>pivot){
            j++;
        }
        if(i<=j){
            swap(array,i,j);
            i++;
            j--;
        }
    }
   return i;
};

//希尔排序
//思想：把数组按照步长gap分组，对分组的数组进行插入排序，随着步长逐渐减小，减小到1时，整个数据合成为一组。
function shellSort(){
        var N=arr.length;
        var h=1;
        while(h<N/3){
                h=3*h+1;//设置间隔
        }
        while(h>=1){
           for(var i=h; i<N; i++){
              for(j=i; j>=h && arr[j]<arr[j-h]; j-=h){
                   swap(arr, j, j-h);
                  }
                 }
            h=(h-1)/3;
        }
    }
 function swap(array, i, j){//两个数调换
        var temp =array[j];
        array[j]=array[i];
        array[i]=temp;
}

//堆排序：
function HeapAdjust(l, s, m) {//使用调整大顶堆进行排序，将s到m之间的数值调整为大顶堆！
    var temp = l[s];//将大顶堆顶值负值给temp
    for (var j = 2 * s + 1; j < m; j = 2 * j + 1)//由于下标是0;这里只从0，1，3，5...每列的第一个数字开始遍历就行
    {
        if (j < m && l[j] < l[j + 1])//如果当前下标的值比下一个下标的数值比下一个小（我们是要找最大的那个），则就使j+1指向那个数字
            ++j;
        if (temp >= l[j])//如果堆顶的值大于当前j下标的值，就不用再找了。跳出循环
            break;
        l[s] = l[j];//小于j下标的值，就把l[j]复制给l[s]
        s = j;//s就指向当前j的位置，为下步把顶值赋值到这个位置做准备（循环完之前，先不赋值）
    }
    l[s] = temp;//最后赋值给l[s]（s指向现在找到的最大的大堆顶的值）
}
function HeapSort(l) {
    for (var i = l.length / 2; i >= 0; i--)//首先构造一个标准的大堆顶，只需要遍历二叉树一半的节点，就能够把大堆顶构造出来
        HeapAdjust(l, i, l.length);
    for (var i = l.length; i > 0; i--) {//构造完之后 把堆顶的值和最后一个互换，然后 排除最后一个继续进行打造大堆顶！
        swap(l, 0, i - 1);
        HeapAdjust(l, 0, i - 2);
    }
}
function swap(l, i, j) {
    var temp = l[i];
    l[i] = l[j];
    l[j] = temp;
}