排序算法

交换数组中元素位置

function swap(x,y,arr){
    let temp = arr[x]
    arr[x] = arr[y]
    arr[y] = temp
}

冒泡排序：比较相邻的两个项，如果第一个比第二大，则交换它们。元素项向上移动至正确的顺序。

冒泡排序升级版：如果从内循环减去外循环中已跑过的轮数,就可以避免循环中所有不必要的比较

本质上是：每循环一次内层循环，都会将当前最大的值放置arr.length - i的位置，可以看console.log(arr)的值

const bubbleSort = (arr = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const len = arr.length
    for (let i = 0; i < len; i++) {
        for (let j = 0; j < len - i; j++) {
            const cv = arr[j],
                nv = arr[j + 1]
            if (cv > nv) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
            }
        }
    }
    return arr
}

选择排序：找到数据结构中最小值并将其放置第一位，接着找到第二小的值并将其放在第二位，以此类推。

个人理解：选择排序和冒泡排序是相反的两个操作，选择排序是每轮循环都将最小值放置i的位置，可以看console.log(arr)的值

const selectSort = (arr = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const len = arr.length
    for (let i = 0; i < len - 1; i++) {
        const iv = arr[i]
        let minIdx = i
        for (let j = i + 1; j < len; j++) {
            const jv = arr[j]
            if (jv < arr[minIdx]) {
                minIdx = j
            }
        }
        if (iv > arr[minIdx])[arr[i], arr[minIdx]] = [arr[minIdx], arr[i]]
    }
    return arr
}

插入排序：每次排一个数组项以此方式构建最后的排序数组。

function insertSort(arr){
    for(let i = 1;i < arr.length;i++){
        let preIndex = i - 1,current = arr[i]
        while(preIndex >= 0 && current < arr[preIndex]){
            arr[preIndex + 1] = arr[preIndex];
            preIndex--;
        }
        arr[preIndex + 1] = current;
    }
    return arr
}

归并排序

const mergeSort = (arr = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const len = arr.length
    if (len === 1) return arr
    const midIdx = Math.floor(len / 2),
        left = arr.slice(0, midIdx),
        right = arr.slice(midIdx)
    const merge = (left, right) => {
        let l = 0,
            r = 0,
            leftLen = left.length,
            rightLen = right.length,
            arr = []
        while (l < leftLen && r < rightLen) {
            if (left[l] < right[r]) {
                arr.push(left[l++])
            } else {
                arr.push(right[r++])
            }
        }
        while (l < leftLen) {
            arr.push(left[l++])
        }
        while (r < rightLen) {
            arr.push(right[r++])
        }
        return arr
    }
    return merge(mergeSort(left), mergeSort(right))
}

归并排序图解说明

快速排序

/**
* 递归 + 二分法
* 使用splice 影响性能：建议使用slice
*/

const quickSort = (arr = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const len = arr.length
    if (len <= 1) return arr
    const left = [],
        right = []
    const base = arr[0]
    for (let i = 1; i < len; i++) {
        const v = arr[i]
        if (v < base) {
            left.push(v)
        } else {
            right.push(v)
        }
    }
    return quickSort(left).concat(base, quickSort(right))
}

快速排序图解说明

计数排序升级版：使用min避免避免空间浪费

const countSort = (arr = [2, 35, 5, 6, 47, 5, 7, 7, 89, 5, 32, 4, 23, 2, 34]) => {
    const len = arr.length
    const min = Math.min(...arr),
        max = Math.max(...arr)
    let init = new Array(max - min + 1).fill(0)
    for (let i = 0; i < len; i++) {
        const v = arr[i]
        init[v - min]++
    }
    let res = []
    for (let i = 0; i < init.length; i++) {
        let v = init[i]
        while (v > 0) {
            res.push(i + min)
            v--
        }
    }
    return res
}

基数排序:这个排序有点意思,根据数值的基数位的值分别排序最后得到的排序数组 暂未添加

function radixSort(sort){
 
}