Java递归快速排序中静态变量的状态管理与陷阱

// 初始列表填充
dlinkedList dList = Operations.fillList(); 

// 第一次排序
dlinkedList list = dlinkedList.quicksortPrice(dList);
dlinkedList.printAllElements(list);
System.out.println(" sorted once ");

// 第二次排序，问题在此显现
list = dlinkedList.quicksortPrice(dList);
dlinkedList.printAllElements(list);
System.out.println(" sorted twice ");

static dlinkedList sortedList = new dlinkedList(); // 静态变量，问题所在
public static dlinkedList quicksortPrice(dlinkedList list) {
    dlinkedList smaller = new dlinkedList();
    dlinkedList greater = new dlinkedList();
    Node y = list.head;
    Node pivot = list.tail; // 假设pivot已正确定义

    if (pivot == null) {
        return sortedList;
    } else {
        // 首次调用或sortedList为空时添加pivot
        if (numberOfElements(sortedList) == 0){
            sortedList.addAtEndOfList(pivot.data);
        }
        // ... 分割逻辑，将元素添加到 smaller, greater, 或 sortedList ...
        while (y != null && y.next != null) { // 遍历列表进行分区
            if (y.data.price < pivot.data.price) {
                smaller.addAtEndOfList(y.data);
            } else if (y.data.price > pivot.data.price) {
                greater.addAtEndOfList(y.data);
            } else { // 等于pivot的元素直接添加到sortedList
                sortedList.insertAfterNode(sortedList.tail, y.data, sortedList);
            }
            y = y.next;
        }

        // ... 将smaller和greater中的元素插入到sortedList的适当位置 ...
        // 递归调用
        if(numberOfElements(smaller) == 0 && numberOfElements(greater) == 0){
            return sortedList;
        }else{
            quicksortPrice(smaller);
            quicksortPrice(greater);
        }
    }
    return sortedList;
}

// 假设 dlinkedList.quicksortPrice 方法是静态的
// dlinkedList empty = new dlinkedList(); // 可以省略，直接赋值新的空列表
dlinkedList sortedResult = dlinkedList.quicksortPrice(dList); // 执行排序
dlinkedList.sortedList = new dlinkedList(); // 关键步骤：重置静态变量
// 现在 sortedResult 包含了排序后的列表，而 dlinkedList.sortedList 已被清空，准备下次使用

// 改进后的 quicksortPrice 方法签名（不再需要静态 sortedList）
public static dlinkedList quicksortPrice(dlinkedList list) {
    if (list == null || list.head == null || list.head.next == null) {
        return list; // 空列表或单元素列表已排序
    }

    // 选择一个枢轴元素 (这里可以优化选择策略)
    Node pivotNode = list.tail; // 假设尾部为枢轴
    Item pivot = pivotNode.data;

    dlinkedList smaller = new dlinkedList();
    dlinkedList greater = new dlinkedList();
    dlinkedList equal = new dlinkedList(); // 处理与枢轴相等的元素

    Node current = list.head;
    while (current != null) {
        if (current.data.price < pivot.price) {
            smaller.addAtEndOfList(current.data);
        } else if (current.data.price > pivot.price) {
            greater.addAtEndOfList(current.data);
        } else {
            equal.addAtEndOfList(current.data);
        }
        current = current.next;
    }

    // 递归排序子列表
    dlinkedList sortedSmaller = quicksortPrice(smaller);
    dlinkedList sortedGreater = quicksortPrice(greater);

    // 合并结果： sortedSmaller -> equal -> sortedGreater
    dlinkedList result = new dlinkedList();
    result.addAll(sortedSmaller); // 将sortedSmaller所有元素添加到result
    result.addAll(equal);         // 将equal所有元素添加到result
    result.addAll(sortedGreater); // 将sortedGreater所有元素添加到result

    return result;
}

// 示例：dlinkedList 增加 addAll 方法
public void addAll(dlinkedList otherList) {
    if (otherList == null || otherList.head == null) {
        return;
    }
    Node current = otherList.head;
    while (current != null) {
        this.addAtEndOfList(current.data);
        current = current.next;
    }
}