4.排序算法，冒泡，归并、快排

书诚小驿2024/10/01前端面经JavaScript

排序算法，冒泡，归并、快排

1、冒泡排序

冒泡排序通过重复遍历待排序的数组，比较相邻元素并交换它们的顺序，直到没有需要交换的元素为止。

function bubbleSort(arr) {
  const n = arr.length;
  // 外层循环：控制排序的轮数，总共需要 n-1 轮
  for (let i = 0; i < n - 1; i++) {
    // 内层循环：每轮比较的次数，每轮比较 n-1-i 次
    // 随着排序的进行，最大的元素会逐渐“冒泡”到数组的末尾
    for (let j = 0; j < n - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        // 交换
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }
  return arr;
}

// 示例
console.log(bubbleSort([5, 2, 9, 1, 5, 6])); // [1, 2, 5, 5, 6, 9]

2、归并排序

归并排序是一个分治算法，将数组分成两半，分别排序，然后合并已排序的部分。

// 归并排序函数
function mergeSort(arr) {
  if (arr.length < 2) return arr;

  const mid = Math.floor(arr.length / 2);
  // arr.slice用于返回数组的一个浅拷贝片段，不会改变原数组
  const left = mergeSort(arr.slice(0, mid));
  const right = mergeSort(arr.slice(mid));

  return merge(left, right);
}

function merge(left, right) {
  const result = [];
  let i = 0,
    j = 0;

  while (i < left.length && j < right.length) {
    if (left[i] < right[j]) {
      result.push(left[i++]);
    } else {
      result.push(right[j++]);
    }
  }

  return result.concat(left.slice(i)).concat(right.slice(j));
}

// 示例
console.log(mergeSort([5, 2, 9, 1, 5, 6])); // [1, 2, 5, 5, 6, 9]

3、选择排序

每次从未排序部分中选择最小（或最大）元素，将其放到已排序部分的末尾。

function selectionSort(arr) {
  const n = arr.length;
  for (let i = 0; i < n - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    // 交换
    [arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];
  }
  return arr;
}

4、快速排序

选择一个“基准”元素，将数组分成两部分，左边是小于基准的元素，右边是大于基准的元素，然后递归地对这两部分进行排序。

function quickSort(arr) {
  if (arr.length <= 1) return arr;
  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

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

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

5、堆排序

利用堆数据结构的特性，首先构建一个最大堆，然后将最大元素（堆顶）交换到数组的末尾，并在剩下的元素中继续调整堆。

function heapSort(arr) {
  const n = arr.length;

  // 建立最大堆
  for (let i = Math.floor(n / 2) - 1; i >= 0; i--) {
    heapify(arr, n, i);
  }

  // 一个个提取元素
  for (let i = n - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]];
    heapify(arr, i, 0);
  }

  return arr;
}

function heapify(arr, n, i) {
  let largest = i;
  const left = 2 * i + 1;
  const right = 2 * i + 2;

  if (left < n && arr[left] > arr[largest]) {
    largest = left;
  }
  if (right < n && arr[right] > arr[largest]) {
    largest = right;
  }
  if (largest !== i) {
    [arr[i], arr[largest]] = [arr[largest], arr[i]];
    heapify(arr, n, largest);
  }
}