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;
}

三、算法选择指南

关键概念：

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

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