快速排序的几种实现方式

73. 快速排序的几种实现方式

1. 基本实现方式

基本实现方式是快速排序最常见的实现方式，具体实现方式如下：

function quickSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }

  const pivotIndex = Math.floor(arr.length / 2);
  const pivot = arr.splice(pivotIndex, 1)[0];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

这种实现方式的思路是：选择数组中的一个元素作为基准值，将数组中小于基准值的元素放到基准值的左侧，大于等于基准值的元素放到基准值的右侧，然后递归地对左右两侧的子数组进行排序。

使用示例：

const arr = [3, 2, 1, 4, 5];
const sortedArr = quickSort(arr);
console.log(sortedArr); // [1, 2, 3, 4, 5]

2. 双指针实现方式

双指针实现方式是一种优化的快速排序实现方式，可以避免对基准值的重复处理。具体实现方式如下：

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left >= right) {
    return;
  }

  const pivotIndex = partition(arr, left, right);
  quickSort(arr, left, pivotIndex - 1);
  quickSort(arr, pivotIndex + 1, right);

  return arr;
}

function partition(arr, left, right) {
  const pivot = arr[right];
  let i = left;

  for (let j = left; j < right; j++) {
    if (arr[j] < pivot) {
      [arr[i], arr[j]] = [arr[j], arr[i]];
      i++;
    }
  }

  [arr[i], arr[right]] = [arr[right], arr[i]];
  return i;
}

这种实现方式的思路与基本实现方式相同，不同之处在于使用双指针的形式来进行数组的排序，可以减少对基准值的重复处理。

使用示例：

const arr = [3, 2, 1, 4, 5];
const sortedArr = quickSort(arr);
console.log(sortedArr); // [1, 2, 3, 4, 5]

3. 随机化实现方式

随机化实现方式是一种通过随机选取基准值来避免最坏情况发生的快速排序实现方式。具体实现方式如下：

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left >= right) {
    return;
  }

  // 随机选取基准值
  const randomIndex = Math.floor(Math.random() * (right - left + 1) + left);
  [arr[randomIndex], arr[right]] = [arr[right], arr[randomIndex]];

  const pivotIndex = partition(arr, left, right);

  quickSort(arr, left, pivotIndex - 1);
  quickSort(arr, pivotIndex + 1, right);
}

function partition(arr, left, right) {
  const pivot = arr[right];
  let i = left;
  for (let j = left; j < right; j++) {
    if (arr[j] < pivot) {
      [arr[i], arr[j]] = [arr[j], arr[i]];
      i++;
    }
  }
  [arr[i], arr[right]] = [arr[right], arr[i]];
  return i;
}

这个实现方式和普通的快速排序非常相似，唯一的区别是在选择基准值的时候采用了随机化的方式，避免了在某些情况下选择最大或最小值作为基准值导致最坏情况的发生。

使用示例：

const arr = [10, 3, 7, 4, 1, 9, 2, 8, 5, 6];
const sortedArr = quickSort(arr);
console.log('After sorting:', sortedArr);// After sorting: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]