排序大全（未完待续）

快速排序

/**
 * @param {Array} arr 需要排序的数组
 */
const sort = arr => {
    if (arr.length <= 1) return arr;
    const short = [];
    const long = [];

    for (let i = 1; i < arr.length; i++) {
        if (arr[0] > arr[i]) {
            short.push(arr[i]);
        } else {
            long.push(arr[i]);
        }
    }
    return [...sort(short), arr[0], ...sort(long)]
};

const numberList = [5, 3, 2, 6, 1, 4, 7, 0];
sort(numberList);

快排的精髓在于从 1 开始遍历

归并排序

/**
 * @param {Array} left 左数组
 * @param {Array} right 右数组
 */
const merge = (left, right) => {
    const result = [];
    while (left.length !== 0 && right.length !== 0) {
        if (left[0] > right[0]) {
            result.push(right.shift());
        } else {
            result.push(left.shift());
        }
    }

    return [...result, ...right, ...left];
};
/**
 * @param {Array} arr 需要排序的数组
 */
const mergeSort = arr => {
    if (arr.length === 1) return arr;
    let flag = Math.floor(arr.length / 2);
    let left = arr.slice(0, flag);
    let right = arr.slice(flag);
    return merge(mergeSort(left), mergeSort(right))
};
let arr = mergeSort([3, 1, 2, 8, 4, 9, 5, 0, 7]);

/*
* merge(mergeSort([3, 1, 2, 8]), mergeSort([4, 9, 5, 0, 7]))
* merge(merge(merge([3], [1]), merge([2], [8])), merge(merge([4], [9]),mergeSort([5, 0, 7])))
* */

归并的精髓在于把所有的 mergeSort 最后都变成了 merge

冒泡排序

/**
 * @param {Array} arr 需要排序的数组
 */
 
const bubbleSort = (arr) => {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - 1 - i; j++) {
            console.log(arr[j], arr[j + 1]);
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j + 1];
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
};

冒泡的精髓在于 arr.length-1 和 arr.length - 1 - i 毕竟最后一个就不用比了么

插入排序

const insertSort = (arr) => {
    //默认第一个元素已经被排序
    for (let i = 1; i < arr.length; i++) {
        //从后往前依次和 当前元素比较 并交换位置
        for (let j = i; j > 0; j--) {
            if (arr[j] < arr[j - 1]) {
                let temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
            } else {
                break
            }
        }
    }
    return arr;
};

插入排序的精髓在于 从 1 开始遍历，因为第一个元素是参照物