Java 排序教程

Java 排序教程

排序是数据处理的核心操作，Java 提供了多种实现方式。本教程涵盖内置排序方法和常用算法实现，帮助您逐步掌握排序技术。

---

一、Java 内置排序方法

1. Arrays.sort()

   适用于基本类型数组和对象数组：

   import java.util.Arrays;
   
   // 整型数组排序
   int[] numbers = {5, 2, 9, 1};
   Arrays.sort(numbers);  // 结果: [1, 2, 5, 9]
   
   // 对象数组排序（需实现Comparable接口）
   String[] names = {"John", "Alice", "Bob"};
   Arrays.sort(names);    // 结果: ["Alice", "Bob", "John"]

2. Collections.sort()

   专为 List 集合设计：

   import java.util.ArrayList;
   import java.util.Collections;
   
   ArrayList<Integer> list = new ArrayList<>();
   list.add(10); list.add(3); list.add(7);
   Collections.sort(list);  // 结果: [3, 7, 10]

---

二、常用排序算法实现

1. 冒泡排序（Bubble Sort）

• 原理：重复比较相邻元素，将较大值向后移动

• 时间复杂度：O(n\^2)

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

2. 插入排序（Insertion Sort）

• 原理：构建有序序列，逐个插入未排序元素

• 时间复杂度：O(n\^2)（最优情况 O(n)）

  public static void insertionSort(int[] arr) {
  for (int i = 1; i < arr.length; i++) {
  int key = arr[i];
  int j = i - 1;
  // 将大于key的元素后移
  while (j >= 0 && arr[j] > key) {
  arr[j + 1] = arr[j];
  j--;
  }
  arr[j + 1] = key; // 插入key到正确位置
  }
  }

3. 快速排序（Quick Sort）

• 原理：分治法，选取基准值分割数组

• 时间复杂度：平均 O(n \\log n)，最差 O(n\^2)

  public static void quickSort(int[] arr, int low, int high) {
  if (low < high) {
  int pi = partition(arr, low, high); // 获取基准点索引
  quickSort(arr, low, pi - 1); // 递归左子数组
  quickSort(arr, pi + 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; j++) {
  if (arr[j] < pivot) {
  i++;
  // 交换小于基准的元素
  int temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
  }
  }
  // 将基准放到正确位置
  int temp = arr[i + 1];
  arr[i + 1] = arr[high];
  arr[high] = temp;
  return i + 1;
  }

---

三、算法选择指南

场景	推荐算法	原因
小规模数据	插入排序	常数因子小，实现简单
通用场景	快速排序	平均性能最优
内存敏感	堆排序	O(1) 额外空间
稳定性要求	归并排序	稳定且 O(n \\log n)
内置实现	Arrays.sort()	优化过的双轴快速排序

关键概念：

• 稳定性：相等元素的相对顺序不变（如插入排序）
• 时间复杂度：衡量算法随数据规模的增长速度
• 空间复杂度：算法运行所需的额外存储空间

通过本教程，您可掌握 Java 排序的核心方法。建议从内置方法入手，再逐步实现经典算法以加深理解。