下面都是将整数数组排序为升序
// 使用到的原地交换方法
const swap = (nums: number[], i: number, j: number) => {
;[nums[i], nums[j]] = [nums[j], nums[i]]
}冒泡排序（Bubble Sort）
通过连续地比较与交换相邻元素实现排序。这个过程就像气泡从底部升到顶部一样，因此得名冒泡排序。
const bubbleSort = (nums: number[]) => {
for (let i = nums.length - 1; i > 0; i--) {
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
swap(nums, j, j + 1)
}
}
}
}选择排序（Selection Sort）
从未排序区间查找最小的元素，将其放到已排序区间的末尾。
const selectionSort = (nums: number[]) => {
for (let i = 0; i < nums.length - 1; i++) {
let k = i
for (let j = i + 1; j < nums.length; j++) {
if (nums[j] < nums[k]) {
k = j
}
}
swap(nums, i, k)
}
}插入排序（Insertion Sort）
逐个将元素插入已排序部分，形成新的有序列表。
const insertionSort = (nums: number[]) => {
for (let i = 1; i < nums.length; i++) {
const base = nums[i]
let j = i - 1
while (j >= 0 && nums[j] > base) {
nums[j + 1] = nums[j]
j--
}
nums[j + 1] = base
}
}快速排序（Quick Sort）
选择一个基准元素，将列表分为两个子列表，小于基准的放在左边，大于基准的放在右边，然后对两个子列表递归地应用相同的方法。
// 交换元素使返回索引 i 满足 nums[a] <= nums[i] <= nums[b] (a∈[left,i]; b∈[i,right]; nums[i]==nums[left])
const partition = (nums: number[], left: number, right: number): number => {
// 以 nums[left] 为基准数；优化可以先选择几个数把中位数交换到 left 位置上，使交换后左右数量尽可能平均
let [i, j] = [left, right]
while (i < j) {
while (i < j && nums[j] >= nums[left]) j-- // 这两个 while 在这种含等号循环条件下不能交换顺序；
while (i < j && nums[i] <= nums[left]) i++ // 因为外层 while 循环结束时（i==j)，还会交换 nums[left] 与 nums[i]，需满足 nums[i] <= nums[left] 才行
swap(nums, i, j)
}
swap(nums, left, i)
return i
}
const quickSort = (nums: number[], left: number, right: number) => {
if (left >= right) return
const pivot = partition(nums, left, right)
quickSort(nums, left, pivot - 1)
quickSort(nums, pivot + 1, right)
}三路快排
const partition = (nums: number[], left: number, right: number): [number, number] => {
let [l, r, i] = [left, right, left + 1]
const pivot = nums[left]
while (i <= r) {
if (nums[i] < pivot) swap(nums, i++, l++)
else if (nums[i] > pivot) swap(nums, i, r--)
else i++
}
return [l, r]
}
const quickSort3Way = (nums: number[], left: number, right: number) => {
if (left >= right) return
const [l, r] = partition(nums, left, right)
quickSort3Way(nums, left, l - 1)
quickSort3Way(nums, r + 1, right)
}归并排序（Merge Sort）
一种基于分治策略的排序算法：
- 划分阶段：通过递归不断地将数组从中点处分开，将长数组的排序问题转换为短数组的排序问题。
- 合并阶段：当子数组长度为 1 时终止划分，开始合并，持续地将左右两个较短的有序数组合并为一个较长的有序数组，直至结束。
const merge = (nums: number[], left: number, mid: number, right: number) => {
const tmp = new Array<number>(right - left + 1)
let [i, j, k] = [left, mid + 1, 0]
while (i <= mid && j <= right) tmp[k++] = nums[i] <= nums[j] ? nums[i++] : nums[j++]
// 将左子数组和右子数组的剩余元素复制到临时数组中
while (i <= mid) tmp[k++] = nums[i++]
while (j <= right) tmp[k++] = nums[j++]
// 将临时数组 tmp 中的元素复制回原数组 nums 的对应区间
for (k = 0; k < tmp.length; k++) nums[left + k] = tmp[k]
}
const mergeSort = (nums: number[], left: number, right: number) => {
if (left >= right) return
const mid = (left + right) >> 1
mergeSort(nums, left, mid)
mergeSort(nums, mid + 1, right)
merge(nums, left, mid, right)
}堆排序（Heap Sort）
利用堆数据结构，将列表转换为最大堆（最小堆），然后每次从堆顶取出最大（最小）元素，重新调整堆结构。
// 堆的长度为 len，从节点 i 开始，从顶至底堆化
const ajustHeap = (nums: number[], i: number, len: number) => {
while (true) {
const [l, r] = [2 * i + 1, 2 * i + 2] // 左右节点索引
let max = i // 记录根与左右子节点中最大值的索引
if (l < len && nums[l] > nums[max]) max = l
if (r < len && nums[r] > nums[max]) max = r
// 若节点 i 最大或索引 l, r 越界，则无须继续堆化，跳出
if (max == i) break
swap(nums, i, max)
i = max
}
}
const heapSort = (nums: number[]) => {
for (let i = (nums.length >> 1) - 1; i >= 0; i--) ajustHeap(nums, i, nums.length) // 建堆操作（从树的倒数第二层最后一个元素开始）
for (let i = nums.length - 1; i > 0; i--) {
swap(nums, 0, i)
ajustHeap(nums, 0, i) // 以根节点为起点，从顶至底进行堆化
}
}前述几种排序算法都属于“基于比较的排序算法”，它们通过比较元素间的大小来实现排序，此类排序算法的时间复杂度无法超越 O(nlogn)。下面几种“非比较排序算法”，它们的时间复杂度可以在理想情况下达到线性阶。
桶排序（Bucket Sort）
它通过设置一些具有大小顺序的桶，每个桶对应一个数据范围，将数据分配到各个桶中；然后在每个桶内部分别执行排序（语言自带的排序方法）；最终按照桶的顺序将所有数据合并。
桶排序适用于处理体量很大的数据。
桶排序的时间复杂度理论上可以达到 O(n)，关键在于将元素均匀分配到各个桶中，因为实际数据往往不是均匀分布的。
计数排序（Counting Sort）
统计每个元素的出现次数，然后按照统计信息重建排序后的列表。
适用于数据量大但数据范围较小的整数数组。
const countingSort = (nums: number[]) => {
// 找到最大值
const max = Math.max(...nums)
// 统计各数字的出现次数
const counter = new Array<number>(max + 1).fill(0)
for (const num of nums) counter[num]++
// 求 counter 的前缀和，将“出现次数”转换为“尾索引”；即 counter[num]-1 是 num 在 ans 中最后一次出现的索引
for (let i = 0; i < max; i++) counter[i + 1] += counter[i]
// 倒序遍历 nums ，将各元素填入结果数组 ans。倒序遍历 nums 可以避免改变相等元素之间的相对位置，从而实现稳定排序。
const ans = new Array<number>(nums.length)
for (let i = nums.length - 1; i >= 0; i--) {
const num = nums[i]
ans[--counter[num]] = num
}
// 使用结果数组 ans 覆盖原数组 nums
for (let i = 0; i < nums.length; i++) nums[i] = ans[i]
}基数排序（Radix Sort）
核心思想与计数排序一致，也通过统计个数来实现排序。在此基础上，基数排序利用数字各位之间的递进关系，依次对每一位进行排序，从而得到最终的排序结果。
适用于数值范围较大的情况，但前提是数据必须可以表示为固定位数的格式，且位数不能过大。
// 获取元素 num 的第 k 位，其中 exp = 10^(k-1)，传入 exp 而非 k 可以避免在此重复执行昂贵的次方计算
const digit = (num: number, exp: number) => Math.floor(num / exp) % 10
// 计数排序（根据 nums 第 k 位排序）
const countingSortDigit = (nums: number[], exp: number) => {
const counter = new Array(10).fill(0)
for (let i = 0; i < nums.length; i++) counter[digit(nums[i], exp)]++
for (let i = 1; i < counter.length; i++) counter[i] += counter[i - 1]
const ans = new Array<number>(nums.length)
for (let i = nums.length - 1; i >= 0; i--) {
const d = digit(nums[i], exp)
ans[--counter[d]] = nums[i]
}
for (let i = 0; i < nums.length; i++) nums[i] = ans[i]
}
const radixSort = (nums: number[]) => {
const max = Math.max(...nums)
for (let exp = 1; exp <= max; exp *= 10) countingSortDigit(nums, exp)
}