数据结构基础复习——排序算法的关键代码片段

针对数据结构考试中常见的代码填空题，我为你整理了上述核心排序算法的关键代码片段。考试时，出题人通常会挖空循环边界条件 、元素比较条件 或核心交换逻辑。

1. 冒泡排序 (Bubble Sort)

🎯 核心考点：内外层循环的边界控制、相邻元素的比较与交换。

public void bubbleSort(int[] arr) {
    int n = arr.length;
    // 考点1：外层循环控制趟数，n个元素最多需要 n-1 趟
    for (int i = 0; i < n - 1; i++) { 
        // 考点2：内层循环控制每趟比较次数，末尾已固定的 i 个元素不用再比
        for (int j = 0; j < n - 1 - i; j++) { 
            // 考点3：比较条件（升序排序时，前一个大于后一个才交换）
            if (arr[j] > arr[j + 1]) { 
                // 考点4：交换逻辑（临时变量 temp 的用法）
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

2. 直接插入排序 (Insertion Sort)

🎯 核心考点：待插入元素的暂存（防止覆盖）、元素后移条件、最终插入位置。

public void insertionSort(int[] arr) {
    for (int i = 1; i < arr.length; i++) {
        int key = arr[i]; // 考点1：暂存待插入元素
        int j = i - 1;
        // 考点2：边比较边后移（注意 j >= 0 防止数组越界）
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j]; // 元素向后移动
            j--;
        }
        // 考点3：将元素插入到正确位置（注意是 j+1，因为最后 j-- 了一次）
        arr[j + 1] = key; 
    }
}

3. 简单选择排序 (Selection Sort)

🎯 核心考点：记录最小（大）元素的下标、一趟结束后才进行交换。

public void selectionSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i < n - 1; i++) {
        int minIdx = i; // 考点1：假设当前位置为最小值下标
        // 考点2：在未排序区间寻找真正的最小值下标
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIdx]) {
                minIdx = j; // 更新最小值下标
            }
        }
        // 考点3：一趟结束后，将找到的最小值与当前位置交换
        if (minIdx != i) { 
            int temp = arr[i];
            arr[i] = arr[minIdx];
            arr[minIdx] = temp;
        }
    }
}

4. 快速排序 (Quick Sort)

🎯 核心考点：基准元素(Pivot)的选取、划分(Partition)过程中的指针移动与交换、递归调用的边界。

public void quickSort(int[] arr, int low, int high) {
    // 考点1：递归终止条件
    if (low < high) { 
        int pivotIndex = partition(arr, low, high);
        // 考点2：递归处理左右子数组（注意边界是 pivotIndex - 1 和 pivotIndex + 1）
        quickSort(arr, low, pivotIndex - 1); 
        quickSort(arr, pivotIndex + 1, high); 
    }
}

// 划分函数（以最右侧元素为基准的常见写法）
private int partition(int[] arr, int low, int high) {
    int pivot = arr[high]; // 考点3：选取基准元素
    int i = low - 1;       // 指向较小元素区域的右边界
    for (int j = low; j < high; j++) {
        // 考点4：当前元素小于基准，则将其放入较小元素区域
        if (arr[j] < pivot) { 
            i++;
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    // 考点5：将基准元素放到最终的正确位置
    int temp = arr[i + 1];
    arr[i + 1] = arr[high];
    arr[high] = temp;
    return i + 1; // 返回基准元素的最终下标
}

5. 归并排序 (Merge Sort)

🎯 核心考点：中点计算、递归拆分、合并时的条件判断与剩余元素拷贝。

// 合并函数
private void merge(int[] arr, int left, int mid, int right) {
    int[] temp = new int[right - left + 1]; // 辅助数组
    int i = left, j = mid + 1, k = 0;
    
    // 考点1：双指针比较，将较小的放入辅助数组
    while (i <= mid && j <= right) {
        if (arr[i] <= arr[j]) { // 注意 <= 保证稳定性
            temp[k++] = arr[i++];
        } else {
            temp[k++] = arr[j++];
        }
    }
    // 考点2：处理左半部分剩余元素
    while (i <= mid) temp[k++] = arr[i++];
    // 考点3：处理右半部分剩余元素
    while (j <= right) temp[k++] = arr[j++];
    
    // 考点4：将辅助数组拷贝回原数组
    System.arraycopy(temp, 0, arr, left, temp.length);
}

---

💡 考试避坑指南（填空前必看）：

1. 看清排序方向 ：题目要求是升序 还是降序 ，这直接决定了 if 条件里是 > 还是 <。
2. 边界条件 +1 或 -1 ：如冒泡的 n - 1 - i，插入排序的 j + 1，快排的 pivotIndex - 1，这些是最容易挖空的地方。
3. 交换的三行代码 ：如果题目留了三个空让你写交换，一定要记住经典的"存值 → 赋值 → 赋值 "顺序，切忌直接 a = b; b = a;。
4. 数组越界风险 ：在填写 while 循环条件时，务必检查是否有类似 j >= 0 或 i <= mid 这样的防越界条件。