常用排序算法：堆排序

知识补给：

1. 堆是一颗完全二叉树；
2. 堆结构分为最大堆和最小堆：最大堆就是任一节点大于等于其左右子节点，最小堆就是任一节点小于等于其左右子节点；
3. 要进行堆排序，首先先原地建堆，即将数组元素调整为最大堆/最小堆结构，然后再根据最大堆/最小堆的特性对堆结构进行排序。

/**
 * 将数组中索引值为 i 和 j 的元素交换
 * @param arr 操作数组
 * @param i 元素1的索引值
 * @param j 元素2的索引值
 */
function swap(arr: number[], i: number, j: number) {
  const temp = arr[i]
  arr[i] = arr[j]
  arr[j] = temp

  // ES6 语法：利用数组的解构赋值亦可实现数组元素交换
  // [arr[i], arr[j]] = [arr[j], arr[i]]
}

/**
 * 对数组进行堆排序
 * @param arr 待排序的数组
 * @param isAsc 是否为升序排序（从小到大）
 * @return 排好序后的原数组
 */
function heapSort(arr: number[], isAsc: boolean = true): number[] {
  // 1. 获取数组的长度
  const n = arr.length

  // 2. 对 arr 进行原地建堆
  // 2.1 从第一个非叶子节点开始进行向下调整，调整完成后，往前移，继续向下调整，直到根节点
  const start = Math.floor(n / 2 - 1)
  for (let i = start; i >= 0; i--) {
    // 2.2 进行向下调整
    adjustmentDown(arr, n, i, isAsc)
  }

  // 上面已经完成了最大堆/最小堆的建堆操作
  // 下面是对原数组进行升序/降序排序操作

  // 3. 对最大堆/最小堆进行排序: 当未经排序的元素个数大于等于 2 时，才需要进行排序
  // i 表示未经排序的元素中的最后一个元素的索引
  for (let i = n - 1; i > 0; i--) {
    // 将数组第一个元素（堆顶-最大值/最小值）和数组最后一个元素交换，然后“取出”最大值/最小值（最后一个元素），最后对堆顶元素进行向下调整
    swap(arr, 0, i)
    // 下滤，重新形成最大堆/最小堆，每次固定一个值的位置
    adjustmentDown(arr, i, 0, isAsc)
  }

  return arr
}

/**
 * 向下调整函数：调整为最大堆/最小堆
 * @param arr 要进行向下调整的数组
 * @param n 数组的长度
 * @param index 要进行向下调整的元素的索引
 * @param isAsc 是否为升序排序（从小到大）
 */
function adjustmentDown(arr: number[], n: number, index: number, isAsc: boolean = true) {
  // 如果有左子节点，才会继续循环（堆为完全二叉树）
  // 完全二叉树：2 * i + 1 为 i 的左子节点，2 * i + 2 为 i 的右子节点
  while (2 * index + 1 < n) {
    // 1. 获取左右子节点的索引
    const leftChildIndex = 2 * index + 1
    const rightChildIndex = 2 * index + 2

    // 2. 找到左右子节点中的最大值/最小值
    let currentIndex = leftChildIndex
    // 升序：记录索引值为 index 的节点的最大子节点的索引值
    if (isAsc && rightChildIndex < n && arr[rightChildIndex] > arr[leftChildIndex]) {
      currentIndex = rightChildIndex
    }
    // 降序：记录索引值为 index 的节点的最小子节点的索引值
    if (!isAsc && rightChildIndex < n && arr[rightChildIndex] < arr[leftChildIndex]) {
      currentIndex = rightChildIndex
    }

    // 已经形成最大堆/最小堆，直接结束循环
    const flag = isAsc ? arr[index] >= arr[currentIndex] : arr[index] <= arr[currentIndex]
    if (flag) {
      break
    }

    // 交换位置
    swap(arr, index, currentIndex)
    // 重新设置当前需要下滤的元素的索引
    index = currentIndex
  }
}

const nums = [6, 1, 66, 88, 999, 666, 168, 12]
// 升序排序
const newNumsAsc = heapSort(nums)
console.log(newNumsAsc)
// [1, 6, 12, 66, 88, 168, 666, 999]
// 降序排序
const newNumsDesc = heapSort(nums, false)
console.log(newNumsDesc)
// [999, 666, 168, 88, 66, 12, 6, 1]
// 当前堆排序会改变原数组，如果不想改变原数组，可以使用深度克隆，克隆一个用于排序使用的新数组
console.log(nums)
// [999, 666, 168, 88, 66, 12, 6, 1]