Java 就地快速排序灾难

我已经为此挣扎了好几个小时了。我正试图按照以下步骤在Java中构建一个就地快速排序。是的，我已经尝试过逐字实现这个示例，但是它有一个无限循环的问题。但不管怎么说，逻辑似乎是合理的，所以我花了几个小时来努力修好它

我一辈子都不能让这该死的东西工作——这里有一个SSCCE使用一个简单的列表：

15、12、13

。事情会在我期望的时候进行排序，但是子列表没有正确地分割。如果删除交换区域中的指针，则不支持重复。有人能帮我一下吗，或者给我指一个类似的可以工作的实现（我看起来没有成功）

SSCCE，无痕迹：

import java.util.Arrays;
import java.util.List;

public class Quicksort {
public static void main(final String[] args0) {
    List<Integer> unsorted = Arrays.asList(new Integer[]{15, 12, 13});

    int size = unsorted.size();
    int left = 0;
    int right = size - 1;
    int pivot = 13; // Median of first, middle, last. Method removed for brevity.

    while (left < right) {
        while (unsorted.get(left).compareTo(pivot) < 0) {
            left++;
        }

        while (unsorted.get(right).compareTo(pivot) > 0) {
            right--;
        }

        if (unsorted.get(left).compareTo(unsorted.get(right)) > 0) {
            int old = unsorted.get(left);
            unsorted.set(left, unsorted.get(right));
            unsorted.set(right, old);

            if (left + 1 < size) {
                left++;
            }
            if (right - 1 >= 0) {
                right--;
            }
        }           
    }

    System.out.println("List: " + unsorted);
    System.out.println("Sublist left: " + unsorted.subList(0, left));  // Yields [13, 15] 
    System.out.println("Sublist right: " + unsorted.subList(left, size)); // Yields [12]
    // ...then recurse for sublists.
}
}

导入java.util.array；
导入java.util.List；
公共类快速排序{
公共静态void main（最终字符串[]args0）{
List unsorted=Arrays.asList（新整数[]{15,12,13}）；
int size=unsorted.size（）；
int左=0；
int right=大小-1；
int pivot=13；//为简洁起见，删除了第一个、中间个和最后一个方法的中间值。
while（左<右）{
while（未排序的.get（左）.compareTo（pivot）<0）{
左++；
}
while（unsorted.get（right）.compareTo（pivot）>0）{
对--；
}
if（unsorted.get（left）.compareTo（unsorted.get（right））>0{
int old=unsorted.get（左）；
unsorted.set（左，unsorted.get（右））；
未排序。设置（右，旧）；
如果（左+1<尺寸）{
左++；
}
如果（右-1>=0）{
对--；
}
}           
}
System.out.println（“列表：+未排序）；
System.out.println（“Sublist left:+unsorted.Sublist（0，left））；//产量[13,15]
System.out.println（“右子列表：+unsorted.Sublist（左，大小））；//产量[12]
//…然后针对子列表递归。
}
}

---

SSCCE，带记录道（同上）：

导入java.util.array；
导入java.util.List；
公共类快速排序{
公共静态void main（最终字符串[]args0）{
List unsorted=Arrays.asList（新整数[]{15,12,13}）；
int size=unsorted.size（）；
int左=0；
int right=大小-1；
int pivot=13；//为简洁起见，删除了第一个、中间个和最后一个方法的中间值。
System.out.println（“--Processing”+未排序）；
系统输出打印LN（“中间带”+枢轴）；
System.out.println（“Left=“+Left+”，right=“+right”）；
while（左<右）{
系统输出打印项次（“开始INC/DEC，left=“+left+”，right=“+right”）；
while（未排序的.get（左）.compareTo（pivot）<0）{
左++；
}
while（unsorted.get（right）.compareTo（pivot）>0）{
对--；
}
系统输出打印项次（“结束INC/DEC，left=“+left+”，right=“+right”）；
if（unsorted.get（left）.compareTo（unsorted.get（right））>0{
int old=unsorted.get（左）；
unsorted.set（左，unsorted.get（右））；
未排序。设置（右，旧）；
如果（左+1<尺寸）{
左++；
}
如果（右-1>=0）{
对--；
}
System.out.println（“结束交换，left=“+left+”，right=“+right+”，list now”+未排序）；
}           
System.out.println（“结束时，left=“+left+”，right=“+right+”，list now”+未排序）；
}
System.out.println（“列表：+未排序）；
System.out.println（“左子列表：+unsorted.Sublist（0，左））；
System.out.println（“右子列表：+未排序的子列表（左，大小））；
//…然后针对子列表递归。
}
}

似乎您在交换之前比较了值：

if (unsorted.get(left).compareTo(unsorted.get(right)) > 0)

参考代码比较索引时：

if left ≤ right

还可以看到比较中的差异：

是的，看起来就是这样（现在！）谢谢！

if left ≤ right