几种简单的排序算法

1、冒泡排序

算法介绍：

1、比较相邻的 两个元素，如果前一个比后一个大，则交换位置；

2、第一轮的时候最后一个元素应该是最大的一个；

3、按照步骤一的方法进行相邻两个元素大的比较，而最后一个不用比较（已最大）。

 

最坏时间复杂度：o(n^2),最好时间复杂度：o(n^2);

function bubble_sort(arr) {

    for(var i=0;i<arr.length-1;i++){

        for(var j=0;j<arr.length-i-1;j++){

            if(arr[j]>arr[j+1]){

                var temp = arr[j];

                arr[j] = arr[j+1];

                arr[j+1] = temp;

            }
        }
    }
}

bubble_sort(arr);

 

2、快速排序

算法介绍：

1、第一趟排序时将数据分成两部分，一部分比另一部分的所有数据都要小；

2、然后递归调用，在两边都实行快速排序。

function quick_sort(arr){

    if(arr.length<=1){

        return arr;
    }

    var pivotIndex = Math.floor(arr.length/2);

    var pivot = arr.splice(pivotIndex,1)[0];//

    var left = [];

    var right = [];

    for(var i=0;i<arr.length;i++){

        if(arr[i]<pivot){

            left.push(arr[i]);
        }
        else{
            right.push(arr[i]);
        }
    }
    return quick_sort(left).concat([pivot],quick_sort(right));
}

quick_sort(arr);

 

3、插入排序

算法介绍：

1、从第一个元素开始，该元素可以认为已经被排序；

2、取出下一个元素，在已经排序的元素序列中从后向前扫描；

3、如果扫描元素大于取出元素，则扫描元素往后移；

4、重复步骤3，直到找到扫描元素中小于或等于取出元素的位置；

5、将取出的元素插入到下一位置中，并重复2。

 

最坏时间复杂度：o(n^2),最好时间复杂度：o(n);

function insert_sort(arr) {

    for(var i=1;i<arr.length;i++){

        var j = i;

        var key = arr[j];

        while(--j>-1){

        if(arr[j]>key){

            arr[j+1] = arr[j];
        }
        else{

            break;
        }
    }
    arr[j+1] = key;
}
    return arr;
}
 
insert_sort(arr);

4、选择排序

算法介绍：

1、令i=0，从 i 到 length-1 开始循环，找到待排数组中的最小值放在i位置上；

2、重复步骤 1；

最坏时间复杂度o(n^2);最好时间复杂度o(n^2);

function select_sort(arr) {

    for(var i=0;i<arr.length-1;i++){

        var min = i;

        for(var j=i+1;j<arr.length;j++){

            if(arr[min] > arr[j]){

                min = j;
            }
        }

        if(min != i){
            var temp = arr[min];

            arr[min] = arr[i];

            arr[i] = temp;
        }
}
    return arr;
}

select_sort(arr);

 

5、希尔排序

算法介绍：

1、选取一个增量d，初始值是Math.floor(len/2);

2、将数组中间隔为增量d的组成新的分组，然后对这个分组的元素排序，完成排序后，增量除以2得到新的增量，d = d/2；

3、重复步骤2，直到增量为1，间隔为1的元素组成的分组就是整个数组，然后在对整个数组进行插入排序。

 

平均复杂度：o(log2n),最好情况复杂度：o(n);不稳定；

function shell_sort(arr) {

    for(var gap = Math.floor.apply(arr.length/2);gap>0;gap = Math.floor(gap/2)){

        for(var i=gap;i<arr.length;i++){

            for(var j=i-gap;j>=0&&arr[j]>arr[j+gap];j-=gap){

                var temp = arr[j];

                arr[j] = arr[j+gap];

                arr[j+gap] = temp;

            }
        }
    }
    return arr;
}

shell_sort(arr);

6、归并排序

算法介绍：

归并排序其实与希尔排序类似，主要区别在于分割数组的方式，主要思想是递归将数组层层分割，直到分割成最小的单元，然后再比较，提供一个新的数组，将分割的左右两个数组中小的数放进数组，然后再层层回溯向上合并，得到排序后的数组

 

平均时间复杂度为o(nlog2n),最好时间复杂度o(nlog2n);

function mergerArray(left,right) {

    while(left.length>0 && right.length>0){

        if(left[0] < right[0]){

            result.push(left.shift());

        }

        else{

            result.push(right.shift());

        }

    }

    return result.concat(left).concat(right);

}

function merger_sort(arr) {

    if(arr.length <= 1){

        return arr;

    }

    var midlle = Math.floor(arr.length/2);

    var left = arr.slice(0,midlle);

    var right = arr.slice(middle);

    return mergerArray(merger_sort(left),merger_sort(right));

}

merger_sort(arr);