使用Java中的霍尔分区对数组进行排序的快速排序算法

我正在尝试通过快速排序对该数组进行排序：

int[] arr = {25,23,21,29,28,22,24,27};

我的快速排序功能：

public static void quickSort(int[] arr) { // sorts array using quick sort algorithm
    if (arr[0] < arr[arr.length-1]) {
        int s = hoarePartitioning(arr);
        quickSort(Arrays.copyOfRange(arr, 0, s-1));
        quickSort(Arrays.copyOfRange(arr, s+1, arr.length));
    }
}

我的霍尔分区函数工作得很好，但我仍然不明白为什么数组没有排序。我做错了什么？

---

谢谢。

快速排序方法基本上是错误的：

    quickSort(Arrays.copyOfRange(arr, 0, s-1));
    quickSort(Arrays.copyOfRange(arr, s+1, arr.length));

每次递归时，都会为左侧和右侧子阵列创建一个新阵列，（尝试）对新阵列进行排序，然后将它们丢弃。最终结果：原始数组没有更改

不要复制子阵列。传递原始数组，以及每个递归调用中要排序的子数组的开始和结束。如有必要，使用辅助功能；e、 g

 public void quicksort(int[] array) {
     quicksort(array, 0, array.length - 1);
 }

 public void quicksort(int[] array, int start, int end) {
     ...
 }

还有一些其他问题：

if

测试看起来错误。在这种情况下，为什么要跳过对阵列/子阵列进行排序？实际测试应该是正在排序的子数组的大小。。。而不是子数组内容

子阵列的上界计算看起来是错误的

s-1

是一个包含性边界，但

arr.length

是一个独占性边界。其中一个肯定是错的

---

作为单个函数的通用霍尔分区代码。对于已排序或反向排序的数据，使用pivot的中间值可以避免最坏情况O（n^2）的时间复杂性。除了[hi]之外的任何元素都可以用作此特定代码的轴心。不需要对索引进行边界检查，因为在最坏的情况下，到达枢轴将停止初始内部循环，任何交换都将允许内部循环在没有边界检查的情况下重复

    public static void qsort(int[] a, int lo, int hi)
    {
        if(lo >= hi)
            return;
        int  p = a[lo+(hi-lo)/2];
        int  i = lo-1;
        int  j = hi+1;
        int t;
        while(true){
            while(a[++i] < p);
            while(a[--j] > p);
            if(i >= j)
                break;
            t     = a[i];
            a[i] = a[j];
            a[j] = t;
        }
        qsort(a, lo, j);
        qsort(a, j+1, hi);
    }

publicstaticvoidqsort（int[]a，int-lo，int-hi）
{
如果（低>=高）
返回；
int p=a[lo+（hi-lo）/2]；
int i=lo-1；
int j=hi+1；
int t；
while（true）{
而（a[++i]p）；
如果（i>=j）
打破
t=a[i]；
a[i]=a[j]；
a[j]=t；
}
qsort（a，lo，j）；
qsort（a，j+1，hi）；
}

感谢您的第一个建议。然而，当我调试时，两个子数组似乎都适合我的边界。我不明白你在说什么。你指的是哪一个“第一个建议”？主要问题还是“其他问题”#1？

 public void quicksort(int[] array) {
     quicksort(array, 0, array.length - 1);
 }

 public void quicksort(int[] array, int start, int end) {
     ...
 }

    public static void qsort(int[] a, int lo, int hi)
    {
        if(lo >= hi)
            return;
        int  p = a[lo+(hi-lo)/2];
        int  i = lo-1;
        int  j = hi+1;
        int t;
        while(true){
            while(a[++i] < p);
            while(a[--j] > p);
            if(i >= j)
                break;
            t     = a[i];
            a[i] = a[j];
            a[j] = t;
        }
        qsort(a, lo, j);
        qsort(a, j+1, hi);
    }