学习参考资料1：Hello 算法 - 排序算法

学习参考资料2：十大经典排序算法

1.选择排序

定义

• 开启一个循环，每轮从未排序区间选择最小的元素，将其放到已排序区间的末尾。

代码

function selectSort(nums) {
    for (let i = 0; i < nums.length; i++) {
        let minIndex = i
        for (let j = i; j < nums.length; j++) {
            if (nums[j] < nums[minIndex]) {
                minIndex = j
            }
        }
        [nums[i], nums[minIndex]] = [nums[minIndex], nums[i]]
    }
}

复杂度

时间复杂度：O(n²)

空间复杂度：O(1)

2.冒泡排序

定义

• 通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。

代码

function bubbleSort(nums) {
    const n = nums.length
    for (let i = 0; i < n - 1; i++) {
        let flag = false
        for (let j = 0; j < n - i - 1; j++) {
            if (nums[j] > nums[j + 1]) {
                [nums[j], nums[j + 1]] = [nums[j + 1], nums[j]]
                flag = true
            }
        }
        if (!flag) break
    }
}

复杂度

时间复杂度：O(n²)

空间复杂度：O(1)

3.插入排序

定义

• 将一个数据元素插入到已经排好序的部分列表的适当位置上。

代码

function insertionSort(nums) {
    for (let i = 1; i < nums.length; i++) {
        for (j = i; j > 0 && nums[j] < nums[j - 1]; j--) {
            [nums[j - 1], nums[j]] = [nums[j], nums[j - 1]]
        }
    }
    return nums
}

复杂度

时间复杂度：O(n²)

空间复杂度：O(1)

4.快速排序

定义

• 快速排序是一种分治算法，它通过选择一个“基准”元素并将数组划分为两个子数组：一个包含小于基准的元素，另一个包含大于基准的元素，然后递归地对这两个子数组进行排序。

代码

function quickSort(arr) {
    if (arr.length < 2) return arr
    const len = arr.length - 1
    let pivot = arr[len]
    const left = [], right = [];
    for (let i = 0; i < len; i++) {
        if (arr[i] < pivot) {
            left.push(arr[i])
        } else {
            right.push(arr[i])
        }
    }
    return [...quickSort(left), pivot, ...quickSort(right)]
}
const arr = [1, 10, 100, 25, 1, 2, 3, 5, 4, 4]
console.log(quickSort(arr));

复杂度

时间复杂度：O(nlogn)

空间复杂度：O(n)

5.归并排序

定义

• 归并排序是一种分治策略的排序算法，它首先将数组分成两半，递归地对每一半进行排序，然后将两个已排序的子数组合并为一个完整的已排序数组。

代码

function mergeSort(nums) {
    const n = nums.length
    if (n < 2) return nums
    const mid = Math.floor(n / 2)
    const left = mergeSort(nums.slice(0, mid))
    const right = mergeSort(nums.slice(mid))
    return merge(left, right)
}
function merge(left, right) {
    const res = []
    while (left.length && right.length) {
        res.push(left[0] < right[0] ? left.shift() : right.shift())
    }
    return [...res, ...left, ...right]
}

复杂度

时间复杂度：O(nlogn)

空间复杂度：O(n)

排序算法基本上掌握这5种就行，都是非常基础的排序算法。