几种简单的排序算法

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);

 

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值