十大排序算法：Java/JavaScript 实现指南

在数据排序的瞬息万变的世界中

在当今数字化世界中，数据无处不在，对其进行有效排序对于各种应用程序和系统至关重要。排序算法在其中扮演着至关重要的角色，它允许我们以高效且有条理的方式组织数据。对于 Java 和 JavaScript 开发人员来说，掌握各种排序算法对于应对各种数据规模和复杂性至关重要。

十大排序算法指南：Java 和 JavaScript

本文将深入探讨十种最常用的排序算法，重点介绍每种算法的优势、局限性以及代码示例。通过了解这些算法，开发人员可以根据自己的特定需求选择最佳排序算法。

1. 冒泡排序：简单直接

冒泡排序以其简单性和易于实现而著称。它通过一遍遍比较相邻元素并交换位置，将最大元素“冒泡”到数组末尾。虽然冒泡排序对于小型数据集很有效，但对于大型数据集来说效率较低。

public static void bubbleSort(int[] arr) {
  int n = arr.length;
  for (int i = 0; i < n - 1; i++) {
    for (int j = 0; j < n - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        // 交换 arr[j+1] 和 arr[j]
        int temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
}

const bubbleSort = (arr) => {
  for (let i = 0; i < arr.length - 1; i++) {
    for (let j = 0; j < arr.length - i - 1; j++) {
      if (arr[j] > arr[j + 1]) {
        // 交换 arr[j+1] 和 arr[j]
        const temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }
};

2. 选择排序：寻找最小值

选择排序采取了一种不同的方法。它遍历数组，找到未排序部分中最小的元素，并将其与未排序部分的第一个元素交换。选择排序比冒泡排序略微高效，但仍然不适合处理大型数据集。

public static void selectionSort(int[] arr) {
  int n = arr.length;
  for (int i = 0; i < n - 1; i++) {
    int minIndex = i;
    for (int j = i + 1; j < n; j++) {
      if (arr[j] < arr[minIndex]) {
        minIndex = j;
      }
    }
    // 交换 arr[minIndex] 和 arr[i]
    int temp = arr[minIndex];
    arr[minIndex] = arr[i];
    arr[i] = temp;
  }
}

const 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;
      }
    }
    // 交换 arr[minIndex] 和 arr[i]
    const temp = arr[minIndex];
    arr[minIndex] = arr[i];
    arr[i] = temp;
  }
};

3. 插入排序：有序地插入

插入排序将每个元素插入到其在已排序部分中的正确位置。通过遍历数组并比较当前元素与已排序部分的元素，它逐步构建一个有序数组。插入排序对于部分排序的数组非常有效。

public static void insertionSort(int[] arr) {
  int n = arr.length;
  for (int i = 1; i < n; i++) {
    int key = arr[i];
    int j = i - 1;
    while (j >= 0 && arr[j] > key) {
      arr[j + 1] = arr[j];
      j--;
    }
    arr[j + 1] = key;
  }
}

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

4. 快速排序：分治策略

快速排序采用分而治之的方法。它选择一个基准元素，将数组分成两个子数组：一个包含小于基准元素的元素，另一个包含大于或等于基准元素的元素。然后递归地对子数组进行排序。快速排序在平均情况下具有很高的效率，但在最坏情况下效率很低。

public static void quickSort(int[] arr, int low, int high) {
  if (low < high) {
    int partitionIndex = partition(arr, low, high);
    quickSort(arr, low, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, high);
  }
}

private static int partition(int[] arr, int low, int high) {
  int pivot = arr[high];
  int i = (low - 1);

  for (int j = low; j <= high - 1; j++) {
    if (arr[j] < pivot) {
      i++;

      // 交换 arr[i] 和 arr[j]
      int temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
  }

  // 交换 arr[i+1] 和 arr[high] (pivot)
  int temp = arr[i + 1];
  arr[i + 1] = arr[high];
  arr[high] = temp;

  return i + 1;
}

const quickSort = (arr, low, high) => {
  if (low < high) {
    let partitionIndex = partition(arr, low, high);
    quickSort(arr, low, partitionIndex - 1);
    quickSort(arr, partitionIndex + 1, high);
  }
};

const partition = (arr, low, high) => {
  let pivot = arr[high];
  let i = low - 1;

  for (let j = low; j <= high - 1; j++) {
    if (arr[j] < pivot) {
      i++;

      // 交换 arr[i] 和 arr[j]
      const temp = arr[i];
      arr[i] = arr[j];
      arr[j] = temp;
    }
  }

  // 交换 arr[i+1] 和 arr[high] (pivot)
  const temp = arr[i + 1];
  arr[i + 1] = arr[high];
  arr[high] = temp;

  return i + 1;
};

5. 归并排序：稳定且高效

归并排序也是一种分治算法。它将数组分成两个子数组，递归地对子数组进行排序，然后合并已排序的子数组。归并排序在所有情况下都具有较高的效率，使其成为大型数据集的可靠选择。

public static void mergeSort(int[] arr, int low, int high) {
  if (low < high) {
    int mid = (low + high) / 2;
    mergeSort(arr, low, mid);
    mergeSort(arr, mid + 1, high);
    merge(arr, low, mid, high);
  }
}

private static void merge(int[] arr, int low, int mid, int high) {
  // 创建两个临时数组
  int[] left = new int[mid - low + 1];
  int[] right = new int[high - mid];

  // 复制数据到临时数组
  for (int i = 0; i < left.length; i++) {
    left[i] = arr[low + i];
  }
  for (int i = 0; i < right.length; i++) {
    right[i] = arr[mid + 1 + i];
  }

  // 合并两个临时数组
  int i =