排序算法——冒泡，选择，插入，快速，归并排序

大致关键代码，没有测试~~

冒泡排序

经过两个循环，在内层循环依次比较相邻两个元素，如果arr[0]>arr[1]则交换两元素位置，时间复杂度为n^2

let arr = [2,1,4,3,6,5,8,9,7,10]；
let temp;
for(i = 0;i<arr.length;i++){
    for(j = 0;j<arr.length;j++){
        if(arr[j]<arr[j+1]){
            temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}
console.log(arr);

选择排序

一个数组序列，选择数组第一个元素当作最小的再依次与后边元素进行比较找到最小的与第一个元素互换，接着进行下一次循环。时间复杂度为n^2

let arr = [2,1,4,3,6,5,8,9,7,10];
let temp;
//一共进行n-1趟比较
for(i = 0;i<arr.length - 1;i++){
    //用current记录最小值的索引，每一次遍历结束后，current代表的都是最小值索引
    current = i;
    for(j = i+1;j<arr.length;j++){
        if(arr[j]<arr[current])current = j;
}
    //将两者互换位置
    if(current != i){
        temp = arr[i];
        arr[i] = arr[current];
        arr[current] = temp;
    }
}
console.log(arr);

插入排序

原理：通过构建有序序列，对于未排序的序列，从中选择一个元素与有序序列元素（从后向前扫描）进行比较，找到相应位置插入。（与我们玩过的纸牌游戏类似）。

时间复杂度：

最好：待排序已经有序， 从前往后走都不用往里面 插入。 时间复杂度为o(n) 。

最坏：待排序列是逆序，每一次都要移位插入。 时间复杂度o(n^2) 是稳定排序

默认拿取数列中第一个元素看作有序序列。

let arr = [2,1,4,3,6,5,8,9,7,10];
let current;
for(i=1;i<arr.length;i++){
    //记录当前待排序元素
    current = arr[i];
    for(var j=i-1;j>=0;j--){
        //如果有序序列元素大于待排序元素，则将待排序元素往前移
        if(arr[j]<current)break;
        arr[j+1] = arr[j];
    }
    //将待排序元素插入
    arr[j+1] = current;
}

快速排序

原理：

1 先从数列中取出一个元素作为基数值.

2 再扫描数列元素，比其小的放到left数组，比其大的放到right数组，这样一次扫描下来得到两个数组

3 再对left和right数组递归执行上边两个操作。直到各区间少于两个元素。

时间复杂度：

最好：待排序无序。时间复杂度o(nlogn)

最坏: 待排序已经有序，基准定义在开始。 时间复杂度为o(n^2) 不稳定排序

function quickSort(arr){
    if(arr.length<2)return;
    let left = [];
    let right = [];
    //基数值
    const temp = arr[0];
    for(i=0;i<arr.length;i++){
        if(arr[i]<temp){
            left.push(arr[i])
        }else{
            right.push(arr[i])      
        }
    }
    //进行递归调用
    return [...quickSort(left),temp,...quickSort(right)]
}
let arr = [2,1,4,3,6,5,8,9,7,10];
quickSort(arr);

归并排序

原理：

将未排序的序列从中劈开分成两半，直至每一部分的数列长度<=2，再对每一部分的数列进行排序，最后将每一部分的数列进行合并成最终完整的有序序列。

时间复杂度：o(nlogn)

let res = [];
function mergeSort(arr){
    if(arr.length<2)return arr;
    //将一整个未排序序列分成若干个序列（折半分裂）
    const num = Math.floor(arr.length/2);
    //得到左右两部分
    let left = mergeSort(arr.slice(0,num));
    let right = mergeSort(arr.slice(num));
    return merge(left,right);
}
function merge(left ,right){
    while(left.length>0 && right.length>0){
        if(left[0]<right[0]){
            res.push(left.shift());
        }else{
            res.push(right.shift());
        }
    }
    return res.concat(left).concat(right)
    
}
let arr = [2,1,4,3,6,5,8,9,7,10];
mergeSort(arr);