常用排序算法：快速排序

/**
 * 将数组中索引值为 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 quickSort(arr: number[], isAsc: boolean = true): number[] {
  partition(0, arr.length - 1)

  // 分割函数
  function partition(left: number, right: number) {
    // 递归结束条件：left 和 right 指向同一个索引位置（元素），或者 left > right
    if (left >= right) return

    // 1. 找到基准元素
    // 通常找到第一个元素或者最后一个元素作为基准元素: 这里选择最后一个元素作为基准值
    const pivot = arr[right]

    // 2. 双指针进行交换操作
    // 确保 pivot 左边都是小于等于 pivot 的数字，右边都是大于等于 pivot 的数字
    let i = left
    let j = right - 1

    while (i <= j) {
      // i 小 j 大，则按从小到大进行排序
      // i 大 j 小，则按从大到小进行排序

      // 从左边开始，找到一个大于等于或者小于等于 pivot 的元素
      const calcCondition = () => (isAsc ? arr[i] < pivot : arr[i] > pivot)
      while (calcCondition()) {
        i++
      }
      // 从右边开始，找到一个小于等于或者大于等于 pivot 的元素
      const calcCondition2 = () => (isAsc ? arr[j] > pivot : arr[j] < pivot)
      while (calcCondition2()) {
        j--
      }

      // 说明我们已经找到了（大于等于 pivot 的元素的索引值 i）和（小于等于 pivot 的元素的索引值 j）
      if (i <= j) {
        // 交换两个元素的位置
        swap(arr, i, j)
        // 交换后，前进一位
        i++
        j--
      }
    }

    // i > j 时，表示当次快排结束，将基准元素 pivot 放在正确的位置上（中间值）
    // 此时，索引 i 位置上的元素是 >= pivot（arr[right]） 的值，所以交换后，也可以保证pivot 左边都是小于等于 pivot 的数字，右边都是大于等于 pivot 的数字
    swap(arr, i, right)

    // 递归调用

    // 基准值 pivot 的左半部分
    partition(left, j)

    // 基准值 pivot 的右半部分
    partition(i + 1, right)
  }

  return arr
}

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