Java Quicksort 实现指南：修正分区逻辑中的参数传递错误

private int partition(int[] list, int li, int hi){
    int pivot = list[hi]; // 选择最后一个元素作为枢轴

    int i = (li - 1); // i 指向小于枢轴元素的区域的右边界

    for (int j = li; j <= hi; j++){
        if (list[j] < pivot){
            i++;
            swap(list, i, j); // 将小于枢轴的元素交换到左侧区域
        }
    }

    // 错误点：此处尝试将枢轴放到正确的位置
    swap(list, list[i + 1], list[hi]); 
    return (i + 1); // 返回枢轴的最终位置
}

swap(list, list[i + 1], list[hi]);

swap(list, i + 1, hi);

private void swap(int[] list, int a, int b){
    if (a >= list.length || b >= list.length){
        return;
    }
    // ... 交换逻辑
}

private void swap(int[] list, int a, int b){
    int temp = list[a];
    list[a] = list[b];
    list[b] = temp;
}

public class Quicksort {

    /**
     * 对整个数组进行快速排序的入口方法。
     * @param list 待排序的整数数组。
     */
    public void sort(int[] list){
        if (list == null || list.length <= 1) {
            return; // 数组为空或只有一个元素，无需排序
        }
        sort(list, 0, list.length - 1);
    }

    /**
     * 递归地对数组的指定子范围进行快速排序。
     * @param list 待排序的整数数组。
     * @param li 子数组的起始索引（low index）。
     * @param hi 子数组的结束索引（high index）。
     */
    private void sort(int[] list, int li, int hi){
        if (li < hi){
            // 获取枢轴的最终位置
            int pi = partition(list, li, hi);
            // 递归排序枢轴左侧的子数组
            sort(list, li, pi - 1);
            // 递归排序枢轴右侧的子数组
            sort(list, pi + 1, hi);
        }
    }

    /**
     * 执行分区操作，将小于枢轴的元素放到左侧，大于枢轴的元素放到右侧，并返回枢轴的最终索引。
     * @param list 待分区的整数数组。
     * @param li 子数组的起始索引。
     * @param hi 子数组的结束索引（同时也是枢轴的初始索引）。
     * @return 枢轴的最终位置索引。
     */
    private int partition(int[] list, int li, int hi){
        int pivot = list[hi]; // 选择最后一个元素作为枢轴值

        int i = (li - 1); // i 指向小于枢轴元素的区域的右边界

        // 遍历从 li 到 hi-1 的元素
        for (int j = li; j < hi; j++){ // 注意：j < hi，不包括枢轴本身
            if (list[j] < pivot){
                i++;
                swap(list, i, j); // 将小于枢轴的元素交换到左侧区域
            }
        }

        // 将枢轴元素放到其最终的正确位置
        // 修正点：传递索引 i + 1 和 hi，而不是它们的值
        swap(list, i + 1, hi); 
        return (i + 1); // 返回枢轴的最终位置
    }

    /**
     * 交换数组中两个指定索引位置的元素。
     * @param list 目标数组。
     * @param a 第一个元素的索引。
     * @param b 第二个元素的索引。
     */
    private void swap(int[] list, int a, int b){
        // 移除不必要的边界检查，因为调用方应确保索引合法
        int temp = list[a];
        list[a] = list[b];
        list[b] = temp;
    }

    // 注意：原始代码中的 getPivot 方法未被使用，且其返回的是值而非索引。
    // 如果需要实现更复杂的枢轴选择策略（如三数取中），应确保返回枢轴的索引。
    // 例如，一个返回枢轴索引的 getPivot 方法可能如下：
    /*
    private int getPivotIndex(int[] list, int li, int hi) {
        // 简单实现三数取中，返回中位数元素的索引
        int mid = li + (hi - li) / 2;
        if (list[li] > list[mid]) {
            swap(list, li, mid);
        }
        if (list[li] > list[hi]) {
            swap(list, li, hi);
        }
        if (list[mid] > list[hi]) {
            swap(list, mid, hi);
        }
        return hi; // 将中位数（现在在mid位置）与hi交换，然后hi作为枢轴
    }
    */
}