1.选择排序

首先在为排序的序列中找到最小（大）的元素，存放在排序序列的起始位置
再从剩余为排序的元素中继续寻找最小（大）的元素，放到已排序序列末位
不断重复，直至所有元素排列完毕

function selection(arr) {
    //保存最小值索引
    let minIndex, temp;
    //循环：获取首个元素
    for(let i=0;i<arr.length - 1;i++) {
        minIndex = i;
        //从i后面一个位置开始找最小值
        for(let j = i + 1; j < arr.length;j++) {
            if(arr[j] < arr[minIndex]) {
                minIndex = j
            }
        }

        //判断派头元素是不是最小值，如果不是交换排头元素和最小值
        if(minIndex !== i) {
            temp = arr[i];
            arr[i] = arr[minIndex]
            arr[minIndex] = temp
        }
    }
    return arr;
}

选择排序方法的时间复杂度为O(n²)，不会占用额为内存空间，所以适用于小规模数据

2.插入排序

将第一待排序序列看做一个有序序列，把第二个元素到最后一个元素看做为排序序列
从头到尾依次扫描为排序序列，将扫描到的每个元素插入有序序列的适当位置

function insertionort(arr) {
    const len = arr.length
    let preIndex, current;

    for(let i = 1; i < len; i++) {
        preIndex = i - 1
        //储存当前需要插入的值
        current = arr[i]
        while(preIndex >= 0 && arr[preIndex] > current) {
            //不断对比，发现后边值小，那么就用前边的值覆盖后一个值
            arr[preIndex + 1] = arr[preIndex]
            preIndex--
        }
        //直至前方出现值小于储存的current，当前位置替换为current
        arr[preIndex + 1] = current
    }

    return arr
}

3.快速排序

所谓快速排序当然是更快的去排序，那我们如何能用更短的时间去进行排序呢？

在我们算法当中有一个分而治之的，也就是说把我们的数据从中间分成两组分别进行排序，这个想起来好像是可以把时间缩短。那这样的方法可行吗，当我们分开之后进行排序我们会发现这样即便是分别排好序之后合并起来依旧是混乱的，那我们究竟应该怎样进行分而治之，今天我们就来研究一下

找到一组数据的中间数
把小的放在左边数据集合，大的放在右边数据集合，这样就可以达到正确的分治效果
不断重复前边两部，最后组合我们就可以达到排序效果

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=<device-width>, initial-scale=1.0">
    <title>Document</title>
</head>
<body>
    <script>
        /**
         *  快速排序
         * @param {*} arr
         * @param {*} left 左边
         * @param {*} right 右边
        */
        function sort(arr, left, right) {
            var len = arr.length
            var partitionIndex // 基准
            var left = left ? left : 0
            var right = right ? right : len

            if(left < right) {
                partitionIndex = partition(arr, left, right)
                sort(arr, left, partitionIndex - 1)
                sort(arr, partitionIndex + 1, right)
            }
            return arr
        }
        /**
         *  分组
         * @param {*} arr
         * @param {*} left 左边
         * @param {*} right 右边
        */
        function partition(arr, left, right) {
            var pivot = left
            var index = pivot + 1
            for(let i=index;i<=right;i++) {
                if(arr[i] < arr[pivot]) {
                    swap(arr, i, index)
                    index++
                }
            }
            swap(arr, pivot, index - 1)
            return index - 1
        }
        /**
         *  交换
         * @param {*} arr
         * @param {*} i
         * @param {*} j
        */
       function swap(arr, i, j) {
           var temp = arr[i]
           arr[i] = arr[j]
           arr[j] = temp
           return arr
       }
       var arr = [1, 3, 6, 14, 2, 7, 4, 15]
       console.log(sort(arr))
    </script>
</body>
</html>

4.冒泡排序

冒泡排序和选择排序有着差不多的逻辑，不断冒泡一组数据找到一个最大的放在最末尾
重新查找剩余元素中的最大值放在未排序的末尾
不断重复

function sort(arr) {
    var len = arr.length
    for(let i = 0;i<len - 1;i++) {
        for(let j = 0;j < len - 1 - i;j++) { //len - 1 - i经过第一次冒泡，最大的数已经排到最后，所以不必再比较最后一个
            if(arr[j] > arr[j + 1]) {
                let temp = arr[j + 1]
                arr[j + 1] = arr[j]
                arr[j] = temp
            }
        }
    }
    return arr
}

5.希尔排序

希尔排序也成递减增量排序算法，是插入排序的一种更高效的改进版本
希尔排序的基本思想：
现将整个带排序的记录序列分割成为若干子序列分别进行插入排序，带整个序列中的记录基本有序时，在对全体记录进行依次直接排序

首先对数据进行分组，第一次分组是每组是由每个数据后第[数据长度/2取整]组成
第二次分组是由第一次数据间隔/2的间隔继续分组
直至间隔为1
然后我们在石油插入排序进行排序

function shellSort(arr) {
    var len = arr.length,//长度
        gap = Math.floor(len/2) //获取间隔（增量序列，也叫间隔）

    for(gap; gap > 0;gap = Math.floor(gap/2)) {
        for(var i=gap;i<len;i++) {
            temp = arr[i]
            for(var j=i-gap;j>=0 && arr[j] > temp; j-=gap) {
                arr[j+gap] = arr[j]
            }
            arr[j+gap] = temp
        }
    }
    return arr;
}

[路飞]_你最爱的排序这里统统有

1.选择排序

2.插入排序

3.快速排序

4.冒泡排序

5.希尔排序