排序算法

冒泡排序（Bubble Sort）

两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止。

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

选择排序（Selection Sort）

通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1 <= i <= n）个记录交换之。

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

插入排序（Insertion Sort）

快速排序（Quick Sort）

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

简单实现：

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

优化实现：

function swap (A, i, j) {
    const t = A[i];
    A[i] = A[j];
    A[j] = t;
}

function divide (A, p, r) {
    const x = A[r - 1];
    let i = p - 1;

    for (let j = p; j < r - 1; j++) {
        if (A[j] <= x) {
            i++;
            swap(A, i, j);
        }
    }

    swap(A, i + 1, r - 1);

    return i + 1;
}

/**
 * 
 * @param {*} A  数组
 * @param {*} p  起始下标
 * @param {*} r  结束下标 + 1
 */
function qsort (A, p = 0, r) {
    r = r || A.length;

    if (p < r - 1) {
        const q = divide(A, p, r);
        qsort(A, p, q);
        qsort(A, q + 1, r);
    }

    return A;
}