JS 常见的排序算法

工作中算法不常用，但是排序经常用。因此在这里整理了几种JS中常见的排序算法。

冒泡排序

1、算法思想：判断两个相邻元素，大于则交换位置
2、算法步骤

1. 从数组中第一个数开始，依次与下一个数比较并次交换比自己小的数，直到最后一个数。如果发生交换，则继续下面的步骤，如果未发生交换，则数组有序，排序结束，此时时间复杂度为O(n)；
2. 每一轮”冒泡”结束后，最大的数将出现在乱序数列的最后一位。重复步骤（1）

3、算法平均复杂度：n(n^2)

  function sortArr(arr) {
        //外层循环，控制趟数，每一次找到一个最大值
        for (var i = 0; i < arr.length; i++) {
            // 内层循环,控制比较的次数，并且判断两个数的大小  -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
    }

快速排序

1、算法思想：取一个基准值，比基准值小的在左边，大的在右边；左右在继续这样的操作，最后合并。
2、算法步骤：

1. 从待排序的n个记录中任意选取一个记录（通常选取第一个记录）为分区标准;
2. 把所有小于该排序列的记录移动到左边，把所有大于该排序码的记录移动到右边，中间放所选记录，称之为第一趟排序
3. 然后对前后两个子序列分别重复上述过程，直到所有记录都排好序。

3、算法平均复杂度：n(n log n)

   function quick_sort(arr) {
        if (arr.length <= 1) {
            return arr
        }
        var quickIndex = Math.floor(arr.length / 2)
        var mid = arr.splice(quickIndex, 1)[0]
        var left = []
        var right = []
        for (var i = 0; i < arr.length; i++) {
            if (arr[i] > mid) {
                left.push(arr[i])
            } else {
                right.push(arr[i])
            }
        }
        return quick_sort(right).concat([mid], quick_sort(left))
    }

选择排序

1、算法思想：从所有记录中选出最小的一个数据元素与第一个位置的记录交换；然后在剩下的记录当中再找最小的与第二个位置的记录交换，循环到只剩下最后一个数据元素为止。
2、算法平均复杂度：n(n^2)

  function selection_sort(arr) {
        var minIndex
        var temp
        var len = arr.length
        for (var i = 0; i < len; i++) {
            minIndex = i
            for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j
                }
            }
            temp = arr[i]
            arr[i] = arr[minIndex]
            arr[minIndex] = temp
        }
        return arr
    }

插入排序

1、算法思想：从待排序的n个记录中的第二个记录开始，依次与前面的记录比较并寻找插入的位置，每次外循环结束后，将当前的数插入到合适的位置。
2、算法平均复杂度：n(n^2)

function insertion_sort(arr) {
        for (var i = 1; i < arr.length; i++) {
            var key = arr[i];
            var j = i - 1;
            while (arr[j] > key) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = key;
        }
        return arr;
    }

归并排序

1、算法思想：将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
3、算法平均复杂度：n(n log n)

 function merge(left, right) {
        var result = []
        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, right)
    }

    function mergeSort(arr) {
        if (arr.length <= 1) {
            return arr
        }
        var mid = Math.floor(arr.length / 2)
        var left = mergeSort(arr.slice(0, mid))
        var right = mergeSort(arr.slice(mid))

        return merge(left, right)
    }