盘点前端基本排序算法

前端

2023-09-13 09:34:45

前端排序算法：数据整理和操纵的关键

什么是排序算法？

排序算法是计算机科学中的基本算法，用于将数据元素按特定顺序（例如升序或降序）排列。它们广泛应用于各种领域，从数据处理到机器学习。

前端常用的排序算法

在前端开发中，有几种常见的排序算法可用于处理和操纵数据。本文将深入探讨六种基本排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。

1. 冒泡排序

原理： 比较相邻元素并交换较大的元素，依次向后冒泡，直到最后一个元素排序。
时间复杂度： O(n^2)
适用场景： 简单场景，数据量较小

代码示例：

function bubbleSort(arr) {
  let swapped = true;
  while (swapped) {
    swapped = false;
    for (let i = 0; i < arr.length - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        let temp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = temp;
        swapped = true;
      }
    }
  }
}

2. 选择排序

原理： 每次在未排序部分中找到最小元素，并将其与未排序部分的第一个元素交换。
时间复杂度： O(n^2)
适用场景： 比冒泡排序效率稍高

代码示例：

function selectionSort(arr) {
  for (let i = 0; i < arr.length - 1; i++) {
    let minIndex = i;
    for (let j = i + 1; j < arr.length; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    let temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
  }
}

3. 插入排序

原理： 将未排序部分的第一个元素插入到已排序部分中适当的位置。
时间复杂度： O(n^2)
适用场景： 插入少量的元素到已排序序列中

代码示例：

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

4. 快速排序

原理： 分治法，选择枢纽元素，将所有小于枢纽的元素移到左，所有大于枢纽的元素移到右。
时间复杂度： O(n log n)（平均），O(n^2)（最差情况）
适用场景： 大数据量排序，效率较高

代码示例：

function quickSort(arr, low, high) {
  if (low < high) {
    let pivotIndex = partition(arr, low, high);
    quickSort(arr, low, pivotIndex - 1);
    quickSort(arr, pivotIndex + 1, high);
  }
}

function partition(arr, low, high) {
  let pivot = arr[high];
  let i = low - 1;
  for (let j = low; j < high; j++) {
    if (arr[j] <= pivot) {
      i++;
      let temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
  }
  let temp = arr[i + 1];
  arr[i + 1] = arr[high];
  arr[high] = temp;
  return i + 1;
}

5. 归并排序

原理： 分治法，将数组分为两半，对两半分别归并排序，然后合并两半。
时间复杂度： O(n log n)
适用场景： 大数据量排序，稳定排序

代码示例：

function mergeSort(arr) {
  if (arr.length <= 1) {
    return arr;
  }
  let mid = Math.floor(arr.length / 2);
  let left = mergeSort(arr.slice(0, mid));
  let right = mergeSort(arr.slice(mid));
  return merge(left, right);
}

function merge(left, right) {
  let mergedArray = [];
  let i = 0;
  let j = 0;
  while (i < left.length && j < right.length) {
    if (left[i] <= right[j]) {
      mergedArray.push(left[i]);
      i++;
    } else {
      mergedArray.push(right[j]);
      j++;
    }
  }
  while (i < left.length) {
    mergedArray.push(left[i]);
    i++;
  }
  while (j < right.length) {
    mergedArray.push(right[j]);
    j++;
  }
  return mergedArray;
}

6. 堆排序

原理： 基于堆数据结构，将数组构建成堆，依次删除堆顶元素，并将其添加到已排序部分。
时间复杂度： O(n log n)
适用场景： 大数据量排序，不稳定排序

代码示例：

function heapSort(arr) {
  buildMaxHeap(arr);
  for (let i = arr.length - 1; i > 0; i--) {
    let temp = arr[0];
    arr[0] = arr[i];
    arr[i] = temp;
    maxHeapify(arr, 0, i);
  }
}

function buildMaxHeap(arr) {
  for (let i = Math.floor(arr.length / 2) - 1; i >= 0; i--) {
    maxHeapify(arr, i, arr.length);
  }
}

function maxHeapify(arr, i, size) {
  let largest = i;
  let left = 2 * i + 1;
  let right = 2 * i + 2;
  if (left < size && arr[left] > arr[largest]) {
    largest = left;
  }
  if (right < size && arr[right] > arr[largest]) {
    largest = right;
  }
  if (largest !== i) {
    let temp = arr[i];
    arr[i] = arr[largest];
    arr[largest] = temp;
    maxHeapify(arr, largest, size);
  }
}