js 排序算法

1.冒泡排序

冒泡排序：是从头比较相邻的元素，将最大值交换到数组的最后一个位置，再从头比较相邻的元素，将次大值交换到数组的倒数第二个位置位置，以此类推

<script>
    var array=[99,12,82,67,44,1,9];
    console.log(maopao_sort(array));
    function maopao_sort(arr){
        if(num.length<=1){
            return arr;
        }
        for (var i = 0; i < arr.length - 1; i++) {   //遍历次数
            for (var j = 0; j < arr.length - 1 - i; j++) {  //每次遍历的比较次数
                if (arr[j] > arr[j + 1]) {
                    var temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        return arr;
    }

</script>

2.插入排序

插入排序：已排好序列中的某元素（以下称元素1） 要加入排好序列的元素（以下称元素2）
从第一个元素开始，认为是已经排好的序列
从第二个元素开始，从后往前依次遍历已经排好的序列，
如果元素1大于（或小于）元素2
将元素2插入到元素1之前的位置上

<script>
    var arr=[99,12,82,67,44,1,9];
    console.log(insert_sort(arr));
    function insert_sort(num){
        if(num.length<=1){
            return;
        }
        for(var i=1;i<num.length;i++){
            now=num[i];
            var before=i-1;
            for(var j=before;j>=0;j--){
                if(now<num[j]){
                    num[j+1]=num[j];
                    num[j]=now;
                }
            }
        }
        return num;
    }
</script>

3.选择排序

选择排序：是在数组中找到最小元素，将其与数组第一个元素进行交换
再在剩下的元素中找到最小的元素，与第二个元素进行交换

<script>
    var arr=[99,12,82,67,44,1,9];
    console.log(sel_sort(arr));
    function sel_sort(num){
        if(num.length<=1){
            return;
        }
        for(var i=0;i<num.length;i++){
            min=num[i];
            for(var j=i;j<num.length;j++){
                if(num[j]<min){
                    var temp=num[j];
                    num[j]=min;
                    min=temp;
                }
            }
            num[i]=min;
        }
        return num;
    }
</script>

4.快速排序

快速排序：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

<script>
    var arr=[99,12,82,67,44,1,9];
    console.log(quick_sort(arr));
    function quick_sort(num) {
        if (num.length <=1) {
            return num;
        }
        var left=[];
        var right=[];
        var center=parseInt((num.length)/2);

            var centernum = num.splice(center, 1);
            for (var i = 0; i < num.length; i++) {
                if (num[i] < centernum) {
                    left.push(num[i]);
                } else {
                    right.push(num[i]);
                }
            }

        return quick_sort(left).concat(centernum,quick_sort(right));
    }

5. 归并排序

先将数组划分为长度为一的子序列，再对子序列排序再合并（相当于两个有序数组的合并）

function devide(arr){  //将数组划分为长度为一的子序列
        if(arr.length<=1){
            return arr;
        }
        var left = arr.slice(0,arr.length/2);
        var right = arr.slice(arr.length/2);
        return merger(devide(left),devide(right));    //子序列依次合并
    }

    function merger(left,right){   //排序并合并
        var newarr=[];
        var i= 0,j= 0;
       while(i<left.length && j<right.length){
            if(left[i]<right[j]){
                newarr.push(left[i]);
                i++;
            }else{
                newarr.push(right[j]);
                j++;
            }
        }
        if(i<left.length){
            newarr.push(...(left.splice(i,left.length-i)));
        }
        if(j<right.length){
            newarr.push(...(right.splice(j,right.length-j)));
        }
        return newarr;
    }

    console.log(devide([9,10,34,21,22,12]));

不稳定排序算法：选择排序、快速排序
稳定排序算法：冒泡排序、插入排序