JS的排序算法

排序是最基本的算法（本文排序为升序Ascending），常见的有以下几种：

1、冒泡排序 Bubble Sort

2、选择排序 Selection Sort

3、插入排序 Insertion Sort

4、快速排序 Quick Sort

5、归并排序 Merge Sort

冒泡排序 Bubble Sort

冒泡排序是最慢的排序算法，同时也是最直观、最容易想到的排序方法。

步骤

1、比较第一个和第二个元素，若第一个元素大于第二个元素，则交换位置。

2、若第一个小于第二个元素，则继续比较第二个和第三个元素，重复步骤1。

3、经过第一轮比较，则至少最大的元素已经被移动到数组最后一个位置，就像“气泡冒出了水面”一样。

4、继续重复步骤1和步骤2

5、排序成功。

代码

function bubbleSort(arr){
    var temp, swapped;
    do {
        // 若本轮循环中，已经没有任何元素交换位置，则说明排序已经完成，退出循环
        swapped = false;
        for(var i =0;i<arr.length;i++){
            if(arr[i] > arr[i+1]) {
                // 若arr[i] > arr[i+1]，则交换arr[i]和arr[i+1]
                temp = arr[i+1];
                arr[i+1] = arr[i];
                arr[i] = temp;
                swapped = true;
            }
        }
    } while (swapped)
    return arr;
}

时间复杂度

O(n2)

选择排序 Selection Sort

在未排序中选择最小的，放在数组第一个位置。然后从剩余未排序数组中，选择最小的，放在第二个位置。遍历重复，最终完成排序。

和冒泡排序一样，时间复杂度太大，实际中不会用到。

步骤

1. 假设第一个元素是最小的，最小的位置记为minIndex=0。依次和后面的元素比较，若第i个元素更小，则更新minIndex=i，一直到数组最后一个元素。

2. 第一遍遍历之后，若minIndex与开始假设最小的位置不同，则交换元素。

3. 重复步骤1和步骤2，直到排序完成。

代码

function selectSort(arr) {
    var length = arr.length,
        swap,
        min;
    for (var i = 0; i < length; i++) {
        // 假设第i个是最小的,min=i
        min = i;
        for (var j = i + 1; j < length; j++) {
            // 如果第j个更小，则min=j
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        // 如果假设的最小的和实际中最小的，不是同一个位置的，则交换位置
        if (min != i) {
            swap = arr[min];
            arr[min] = arr[i];
            arr[i] = swap;
        }
    }
    return arr;
}

时间复杂度

 O(n2)

插入排序 Insertion Sort

假设数组分为左右两个部分：左侧是已排序（Sorted）的，右侧是未排序（Unsorted）的。从右侧未排序中，依次取出一个元素，倒序和排序好的元素对比，放在不大于已排序的位置。

步骤

1. 取出第一个元素，可以认为是已排序的。

2. 取出下一个元素，在已排序中从后向前扫描。

3. 若该元素（已排序）大于新元素，则该元素向后移一位。

4. 重复步骤3，直到直到找到已排序的元素小于或者等于新元素的位置

5. 将新元素插入到该位置后

6. 重复步骤1到步骤5.

代码

function insertionSort(arr) {
    var length = arr.length,
        temp, j;
    for (var i = 0; i < length; i++) {
        // 取得第i个元素,标记为temp
        temp = arr[i];
        j = i - 1;
        // 依次和前面的元素比较，若前面的元素大于temp，则元素向后移动一位，直到不满足条件
        while (j >= 0 && arr[j] > temp) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = temp;
    }
    return arr;
}

快速排序 Quick Sort

快速排序是一种有效率的排序方式。

步骤

1. 选择一个基准元素，通常选择中间的元素。

2. 遍历数组，将比基准元素小的元素放到左边，比基准元素大的元素放到右边。

3. 重复步骤1和步骤2。

代码

function quickSort(arr) {
    // 空数组或是一个元素的数组，直接返回数组
    if (arr.length <= 1) return arr;
    // 取出基准元素
    var pivot = arr.splice(Math.floor(arr.length / 2), 1)[0],
        left = [],
        right = [];
    for (var i = 0, length = arr.length; i < length; i++) {
        // 和基准元素比较大小，分别放在left和right数组中
        if (arr[i] <= pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    // 递归操作
    return quickSort(left).concat(pivot, quickSort(right))
}

时间复杂度

平均时间复杂度：O(NlogN)

归并排序 Merge Sort

是一种分治（divide and conquer ）的算法。

将数组拆分（divide）为小的数组，对小的数组继续拆分，重复操作直至每个数组的元素只有一个。然后比较大小，进行合并。

步骤

1、递归分割数组，直至最小的数组只有一个元素。

2、两个相邻的最小数组单元比较大小，完成排序。

3、两个次一级的最小数组单元比较大小，完成排序。

4、重复操作，完成排序。

代码

// eg:   mergeSort([1,  3, 8, 3, 5, 3, 5, 22])
// divide function:递归将函数切分为只有一个元素的数组
function mergeSort(arr) {
    if (arr.length < 2) return arr;
    var mid = Math.floor(arr.length / 2),
        left = arr.slice(0, mid),
        right = arr.slice(mid);
    return merge(mergeSort(left), mergeSort(right));
}
// conquer function  合并，将分割开的数组合并起来
function merge(left, right) {
    var lLength = left.length,
        rLength = right.length,
        lIndex = 0,
        rIndex = 0,
        result = [];
    // left和right都是已经排序好的
    // 依次比较每个元素大小，将小的元素push进result，直至left或是right中的任意一个元素都已经被push进result
    while (lIndex < lLength && rIndex < rLength) {
        if (left[lIndex] <= right[rIndex]) {
            result.push(left[lIndex++])
        } else {
            result.push(right[rIndex++])
        }
    }
    // 这两种是一样的，因为此时left.slice(lIndex)和right.slice(rIndex)必定有一个是空元素
    // return result.concat(left.slice(lIndex)).concat(right.slice(rIndex))
    return result.concat(left.slice(lIndex)).concat(right.slice(rIndex))
}

时间复杂度

[参考资料]

JS用到的排序：http://khan4019.github.io/front-end-Interview-Questions/sort.html

JS用到的排序：https://juejin.im/post/57dcd394a22b9d00610c5ec8 

可视化的JS排序网站：http://jsdo.it/norahiko/oxIy/fullscreen

冒泡排序：http://www.stoimen.com/blog/2010/07/09/friday-algorithms-javascript-bubble-sort/

选择排序：https://www.nczonline.net/blog/2009/09/08/computer-science-in-javascript-selection-sort/

插入排序：http://codingmiles.com/sorting-algorithms-insertion-sort-using-javascript/

快速排序：http://www.ruanyifeng.com/blog/2011/04/quicksort_in_javascript.html