面试中常见的排序算法

过年正好有空，总结了下面试中常见的排序算法。方便以后回忆。

/**
 * 记忆点：双for循环，次数，对数
 * 步骤：
 *      1.从第一个元素开始，和相邻的元素进行比较，比较len-1次即可。
 *      2.每次比较len-i-1对元素即可。
 */
function bubbleSort(arr) {
    let len = arr.length, temp;
    // 比较的次数
    for (let i = 0; i < len - 1; i++) {
        // 每次比较的对数
        for (let x = 0; x < len - i - 1; x++) {
            if (arr[x] > arr[x + 1]) {
                temp = arr[x + 1];
                arr[x + 1] = arr[x];
                arr[x] = temp;
            }
        }
    }
    return arr
}

/**
 * 记忆点：双for循环，最小值
 * 步骤：
 *      1.把当前第i个元素设为最小值，保存在min变量中，并且保存其下标到index变量中。i=0；
 *      2.用该值和剩余元素进行比较，剩余元素比min小时，重置min，index的值。x=i+1；
 *      3.第一个元素值和min值所在元素进行对换。
 */
function selectSort(arr) {
    let len = arr.length, min, index, temp;
    for (let i = 0; i < len; i++) {
        min = arr[i];
        index = i;
        for (let x = i + 1; x < len; x++) {
            if (arr[x] < min) {
                min = arr[x];
                index = x;
            }
        }
        temp = arr[i];
        arr[i] = min;
        arr[index] = temp
    }
    return arr
}

/**
 * 记忆点：双for循环，扑克
 * 步骤：
 *      1.设第i个元素为无序元素，i=1。x个元素为有序元素，x=i-1。
 *      2.无序元素和有序元素进行比较，当该元素小于有序元素大时，有序元素往左移。arr[x+1] = arr[x] 让位。
 *      3.将无序元素插入有序序列中合适的位置。
 */
function insertSort(arr) {
    let len = arr.length, key, x;
    for (let i = 1; i < len; i++) {
        key = arr[i];
        x = i - 1;
        while (x >= 0 && arr[x] > key) {
            arr[x + 1] = arr[x];
            x--;
        }
        x++;
        arr[x] = key;
    }
    return arr;
}

/**
 * 记忆点：切割，合并，二分法，递归
 * 步骤：
 *      1.第一个函数进行分割，第二个函数进行合并。
 */
function mergeSort(arr) {
    // 切割
    function slice(arr_) {
        if (arr_.length < 2) {
            return arr_
        }
        let mid = Math.floor(arr_.length / 2),
            lef = arr_.slice(0, mid),
            rig = arr_.slice(mid);
        return merge(slice(lef), slice(rig));
    }

    // 合并
    function merge(lef_, rig_) {
        let res = [];
        while (lef_.length && rig_.length) {
            lef_[0] <= rig_[0] ? res.push(lef_.shift()) : res.push(rig_.shift())
        }
        if (lef_.length) res.push(...lef_);
        if (rig_.length) res.push(...rig_);
        return res;
    }

    return slice(arr)
}

/**
 * 记忆点：基数，二分法，递归
 * 步骤：
 *      1.取数组的第一个元素作为基数，剩余值进行比较。i=1
 */
function quickSort(arr) {
    if (arr.length === 0) {
        return []
    }
    let key = arr[0],
        lef = [],
        rig = [];
    for(let i = 1; i < arr.length; i++) {
        if (arr[i] <= key) {
            lef.push(arr[i])
        } else {
            rig.push(arr[i])
        }
    }
    return quickSort(lef).concat(key, quickSort(rig))
}

// console.log(xxxSort([4, 3, 2, 1]));复制代码

参考：

https://www.jianshu.com/p/8d30da8b832e

https://github.com/hustcc/JS-Sorting-Algorithm