算法：数组排序

数组排序总结了5种

冒泡排序：相邻的元素比对，双重循环
选择排序：每次循环找出一个最小值，双重循环
插入排序：设定j左边已经排序好了，右边是未排序的，“每次都排序一下j的左边”
sort排序： js提供的函数，没啥说的【a-b升序/b-a 倒叙】
快速排序：递归，将每个元素分左右【是通过基于来分的，基于是数组某个元素】，递归回显依次排序好返回

准备数据

let arr = [5, 2, 3, 6, 1, 4]

1. 冒泡排序
解析：相邻的元素对比交换他们
精髓在：arr[j]>arr[j+1] 一轮比较所有相邻的元素，如果第一个比第二大，则交换他们 n轮后排序成功

/**
 * 冒泡排序
 * @param arr
 * @returns {*}
 * 解析：相邻的元素 对比 交换他们
 *
 精髓在：arr[j]>arr[j+1]
 一轮比较所有相邻的元素，如果第一个比第二大，则交换他们
 n轮后 排序成功
 */
function f1(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = 0; j < arr.length; j++) {
            // 打开下面注释辅助理解
            // console.log(`第几次循环${i},j的循环${j}--${arr[j] > arr[j + 1]}    ${arr[j]} > ${arr[j+1]}   ${arr}`)
            // 如果前一个比后一个大,则交换位置
            if (arr[j] > arr[j + 1]) {
                let temp = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = temp
            }
        }
    }
    return arr
}

2. 选择排序
解析：每次循环找到一个最小值，n轮循环后，排序成功
精髓在：arr[i] > arr[j]

/**
 * 选择排序
 * @param arr
 * @returns {*}
 * 解析：每次循环找到一个最小值
 * n轮循环后，排序成功
 *
 * 精髓在：arr[i] > arr[j]
 *
 */
function f2(arr) {
    for (let i = 0; i < arr.length; i++) {
        for (let j = i; j < arr.length; j++) {
            // 打开下面注释辅助理解
            // console.log(`第几次循环${i},j的循环${j}--${arr[i] > arr[j]}    ${arr[i]} > ${arr[j]}   ${arr}`)
            if (arr[i] > arr[j]) {
                let temp = arr[i]
                arr[i] = arr[j]
                arr[j] = temp
            }
        }
    }
    return arr
}

3. 插入排序
解析：设定j左边已经排序好了，右边是未排序的，“每次都排序一下j的左边”

/**
 * 插入排序
 * @param arr
 * @returns {*}
 * 解析：设定j左边已经排序好了，右边是未排序的，“每次都排序一下j的左边”
 *
 * 精髓在：while循环里面，
 * 假设：
 * 第一次 j = 0    while(0>0)  false
 * 第二次 j = 1    while(1>0)  true     if(arr[0]>arr[1]) 循环一次
 * 第三次 j = 2    while(2>0)  true     if(arr[1]>arr[2]) if(arr[0]>arr[2]) 循环两次
 * 第四次 j = 3    while(3>0)  true     if(arr[2]>arr[3]) if(arr[1]>arr[3]) if(arr[0]>arr[3]) 循环两次
 * ......
 * 通过上面 假设得出每次都 排序一下j的左边
 */
function f3(arr) {
    for (let i = 0; i < arr.length; i++) {
        let temp = arr[i]
        let j = i
        // 设定 j 左边已经排序了
        while (j > 0) {
            // 打开下面注释辅助理解
            // console.log(`第几次循环${i}  j的循环${j}--${arr[j - 1] > temp}    ${arr[j - 1]} > ${temp}   ${arr}`)
            if (arr[j - 1] > temp) {
                arr[j] = arr[j - 1]
            } else {
                break
            }
            j--
        }
        arr[j] = temp
        // 打开下面注释辅助理解
        // console.log(i, "---", arr, "   ", temp)
    }
    return arr
}

4. sort排序

/**
 * sort函数
 * @param arr
 * @returns {*}
 */
function f4(arr) {
    return arr.sort((a, b) => {
        // 升序，降序就b-a
        return a - b
    })
}

5. 快速排序
解析：从数组中任意选择一个基准，所有比基准小的元素放到基准前面，比基准大的元素放到基准的后面
精髓在：递归，从数组中取一个基数【基数是数组中的元素】，分左右在递归

/**
 *  快速排序
 * @param arr
 * @returns {*[]|*}
 *
 * 解析：从数组中任意选择一个基准，所有比基准小的元素放到基准前面，比基准大的元素放到基准的后面
 *
 * 紧随在：递归，从数组中取一个基数【数组中】，
 */
function f5(arr) {
    if (arr.length < 1) return arr;
    let left = []
    let right = []
    // 基准值，小于基准线的放左边，大于基准线的放右边
    let item = arr[0]

    for (let i = 1; i < arr.length; i++) {
        if (arr[i] < item) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    // 打开下面注释辅助理解
    // console.log(`左边 ${left}  基准值${item}  右边 ${right}`)
    return [...f5(left), item, ...f5(right)]
}