Java快速排序方法中的越界异常：理解递归基线条件的重要性

public ArrayList<Transaction> myQuickSort(ArrayList<Transaction> list){

    ArrayList<Transaction> sorted = new ArrayList<Transaction>();
    ArrayList<Transaction> lesser = new ArrayList<Transaction>();
    ArrayList<Transaction> greater = new ArrayList<Transaction>();

    Transaction pivot = list.get(list.size()-1); // 潜在的异常点

    for (int i = 0; i <= list.size()-1; i++){
            if(list.get(i).compareTo(pivot) < 0){
                    lesser.add(list.get(i));
            }else{
                    greater.add(list.get(i)); // 枢轴元素也会进入greater列表
            }
    }

    lesser = myQuickSort(lesser); // 递归调用
    greater = myQuickSort(greater); // 递归调用

    lesser.add(pivot); // 再次添加枢轴元素，可能导致重复
    lesser.addAll(greater);
    sorted = lesser;

    return sorted;
}

import java.util.ArrayList;
import java.util.List; // 建议使用List接口，更通用

public class BankingSystem {
    // ... (其他类成员和方法保持不变)

    /**
     * 对Transaction对象的ArrayList进行快速排序。
     * 该方法通过创建新的列表进行分区和合并，而不是原地排序。
     *
     * @param list 待排序的Transaction列表。
     * @return 排序后的Transaction列表。
     */
    public ArrayList<Transaction> myQuickSort(ArrayList<Transaction> list){
        // 1. 基线条件：如果列表为空或只包含一个元素，则它已经是有序的。
        if (list.size() <= 1) {
            return list;
        }

        // 2. 选择枢轴：这里选择列表的最后一个元素作为枢轴。
        //    更复杂的枢轴选择策略（如三数取中）可以提高平均性能，避免最坏情况。
        Transaction pivot = list.get(list.size() - 1);

        // 3. 分区：创建三个子列表，分别存储小于枢轴、等于枢轴和大于枢轴的元素。
        ArrayList<Transaction> lesser = new ArrayList<>();
        ArrayList<Transaction> equal = new ArrayList<>(); // 用于存储与枢轴相等的元素
        ArrayList<Transaction> greater = new ArrayList<>();

        // 遍历原始列表，根据与枢轴的比较结果将元素分配到相应的子列表。
        for (Transaction currentTransaction : list) {
            int comparisonResult = currentTransaction.compareTo(pivot);
            if (comparisonResult < 0) {
                lesser.add(currentTransaction);
            } else if (comparisonResult > 0) {
                greater.add(currentTransaction);
            } else { // currentTransaction 等于 pivot
                equal.add(currentTransaction);
            }
        }

        // 4. 递归调用：对小于枢轴和大于枢轴的子列表进行递归排序。
        //    等于枢轴的子列表不需要排序，因为它们彼此相对顺序不影响最终结果。
        lesser = myQuickSort(lesser);
        greater = myQuickSort(greater);

        // 5. 合并：将排序后的“小于”部分、所有“等于”部分和排序后的“大于”部分合并。
        ArrayList<Transaction> sorted = new ArrayList<>();
        sorted.addAll(lesser);   // 添加所有小于枢轴的已排序元素
        sorted.addAll(equal);    // 添加所有等于枢轴的元素（包括枢轴本身及其所有副本）
        sorted.addAll(greater);  // 添加所有大于枢轴的已排序元素

        return sorted;
    }
}