Javascript数组排序

1.冒泡排序

让数组当中相邻的两个数进行比较，数组当中比较小的数值向下沉，数值比较大的向上浮！外层for循环控制循环次数，内层for循环控制相邻的两个元素进行比较。

    function bubbleSort (arr) {
        var len = arr.length
        var temp
        for (var i = 0; i < len; i++) {
            for (var j = 0; j < len - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j]
                    arr[j] = arr[j + 1]
                    arr[j + 1] = temp
                }
            }
        }
    }

2.选择排序

从头至尾扫描序列，找出最小的一个元素，和第一个元素交换，接着从剩下的元素中继续这种选择和交换方式，最终得到一个有序序列。

    function selectionSort (arr) {
        var len = arr.length
        var min, temp
        for (var i = 0; i < len - 1; i++) {
            min = i
            for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[min]) {
                    min = j
                }
            }
            temp = arr[i]
            arr[i] = arr[min]
            arr[min] = temp
        }
    }

3.插入排序

将一个记录插入到已排好序的序列中，从而得到一个新的有序序列（将序列的第一个数据看成是一个有序的子序列，然后从第二个记录逐个向该有序的子序列进行有序的插入，直至整个序列有序）

重点：使用哨兵，用于临时存储和判断数组边界。

    function insertSort (arr) {
        var len = arr.length
        for (var i = 1; i < len; i++) {
            var temp = arr[i]
            var j = i - 1
            while (j >= 0 && arr[j] > temp) {
                arr[j + 1] = arr[j]
                j--
            }
            arr[j + 1] = temp
        }
    }

4.希尔排序

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序，是插入排序的一种更高效的改进版本。

    function shellSort (arr) {
        var len = arr.length
        var gap = 1
        while (gap < len / 3) {
            gap = gap * 3 + 1
        }
        for(gap; gap > 0; gap = Math.floor(gap / 3)) {
            for (var i = gap; i < len; i++) {
                var temp = arr[i]
                var j = i - gap
                while (j >= 0 && arr[j] > temp) {
                    arr[j + gap] = arr[j]
                    j = j - gap
                }
                arr[j + gap] = temp
            }
        }
    }

5.归并排序

将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列

    function merge(left, right) {
        var result = []
        var i = 0, j = 0
        var left_len = left.length, right_len = right.length
        while (i < left_len && j < right_len) {
            if (left[i] < right[j]) {
                result.push(left[i++])
            } else {
                result.push(right[j++])
            }
        }
        while (i < left_len) {
            result.push(left[i++])
        }
        while (j < right_len) {
            result.push(right[j++])
        }
        return result
    }
    
    function mergeSort (arr) {
        var len = arr.length
        if (len < 2) {
            return arr
        }
        var mid = Math.floor(len / 2) 
        var left = arr.slice(0, mid)
        var right = arr.slice(mid)
        return merge(mergeSort(left), mergeSort(right))
    }

6.快速排序

通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序

    function fastSort (arr) {
        var len = arr.length
        if (len < 2) {
            return arr
        }
        var lesser = [], greater = []
        for (var i = 1; i < len; i++) {
            if (arr[i] < arr[0]) {
                lesser.push(arr[i])
            } else {
                greater.push(arr[i])
            }
        }
        return fastSort(lesser).concat(arr[0], fastSort(greater))
    }