前端工程师必备：排序算法实战指南

前端

2023-09-11 13:14:18

前端面试之排序算法秘籍

前端工程师在面试中常常会被问及排序算法的问题，掌握这些算法不仅能提高面试通过率，更能增强你在技术上的竞争力。本文将深入浅出地总结常见的排序算法，助你成为一名排序达人。

排序算法的必备知识

排序算法顾名思义，就是将给定数据按照特定顺序排列的过程。在前端开发中，排序算法常用于各种场景，例如：

数据筛选和展示
性能优化（减少页面加载时间）
用户体验增强（提供高效的数据浏览）

排序算法の種類

前端工程师常用的排序算法包括：

冒泡排序

冒泡排序的原理是不断比较相邻的两个元素，如果前一个元素大于后一个元素，则交换这两个元素。重复这个过程，直到没有元素需要交换为止。

function bubbleSort(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - 1 - i; j++) {
      if (arr[j] > arr[j + 1]) {
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      }
    }
  }

  return arr;
}

插入排序

插入排序的原理是将一个元素插入到已经排好序的子序列中。先将第一个元素设为排好序的子序列，然后遍历剩下的元素，将每个元素插入到正确的位置。

function insertionSort(arr) {
  for (let i = 1; i < arr.length; i++) {
    const current = arr[i];
    let j = i - 1;
    while (j >= 0 && arr[j] > current) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = current;
  }

  return arr;
}

归并排序

归并排序的原理是分而治之。将数组分成两半，递归地对两半进行排序，然后将排好序的两半合并成一个排好序的数组。

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

  const middle = Math.floor(arr.length / 2);
  const left = mergeSort(arr.slice(0, middle));
  const right = mergeSort(arr.slice(middle));

  return merge(left, right);
}

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

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

  while (i < left.length) {
    result.push(left[i++]);
  }

  while (j < right.length) {
    result.push(right[j++]);
  }

  return result;
}

快速排序

快速排序的原理是选取一个元素作为基准，将数组分成两半。比基准小的元素放在基准的左边，比基准大的元素放在基准的右边。递归地对两半进行同样的操作，直到数组被完全排序。

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

  const pivot = arr[0];
  const left = [];
  const right = [];

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

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

堆排序

堆排序的原理是将数组构建成一个最大堆或最小堆。最大堆的父节点比其子节点大，最小堆的父节点比其子节点小。通过不断地调整堆，可以得到一个排好序的数组。

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

  // 排序
  for (let i = arr.length - 1; i > 0; i--) {
    [arr[0], arr[i]] = [arr[i], arr[0]];
    heapify(arr, 0, i);
  }

  return arr;
}

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

  let largest = i;
  if (left < size && arr[left] > arr[largest]) {
    largest = left;
  }
  if (right < size && arr[right] > arr[largest]) {
    largest = right;
  }

  if (largest !== i) {
    [arr[largest], arr[i]] = [arr[i], arr[largest]];
    heapify(arr, largest, size);
  }
}