Java 在快速排序中递归调用partitionStep导致Stackoverflow异常

我尝试为

int[]

实现快速排序算法。我正确地编码了分区步骤，但是我想递归地调用分区步骤方法来对数组进行排序，不幸的是，我向递归调用传递了错误的索引，并且得到了StackOverflow异常

我是基于：

公共类快速排序{
公共静态无效分区（int[]t，int i，int j）{
int start=i，end=j；
int pivot=t[（i+j）/2]；//选择轴作为中间值
System.out.println（“pivot:+pivot”）；
内部温度；
而（ipivot）{//寻找小于或等于
//支点
j--；
}
System.out.println（“i=“+i+”j=“+j+”交换“+t[i]+”和“+t[j]）；
temp=t[i]；//交换
t[i]=t[j]；
t[j]=温度；
i++；//移动到下一个元素
j--；//移动到prev元素
显示器（t）；
}
//我说他们错了
分区（t，start，j）；//数组左侧的分区
分区（t，i，end）；//数组右部分的分区
}
公共静态无效显示（int[]t）{
对于（整数el:t）
系统输出打印（el+“”）；
System.out.println（）；
}
公共静态void main（字符串[]args）{
int[]t={6,4,1,32,5,7,8,6,9,1}；
显示器（t）；
分区（t，0，t.length-1）；
}
}

基本问题是递归没有退出条件。在

分区

方法中没有一条返回语句。当while循环退出时，它只会再次调用

分区

方法。但代码中并没有说“停止对分区进行递归调用”。因此，堆栈溢出

public static void partition(int[] t, int i, int j) {
    if (i >= j)  {
        return;
    }

我想你至少应该在配分函数的顶部这样说。这将清除堆栈溢出

public static void partition(int[] t, int i, int j) {
    if (i >= j)  {
        return;
    }

我也不确定，但这句话不应该：

partition(t, j, end); //partiion for the right part of the array

真的是这样：

partition(t, i+1, end); //partiion for the right part of the array

---

基本问题是递归没有退出条件。在

分区

方法中没有一条返回语句。当while循环退出时，它只会再次调用

分区

方法。但代码中并没有说“停止对分区进行递归调用”。因此，堆栈溢出

public static void partition(int[] t, int i, int j) {
    if (i >= j)  {
        return;
    }

我想你至少应该在配分函数的顶部这样说。这将清除堆栈溢出

public static void partition(int[] t, int i, int j) {
    if (i >= j)  {
        return;
    }

我也不确定，但这句话不应该：

partition(t, j, end); //partiion for the right part of the array

真的是这样：

partition(t, i+1, end); //partiion for the right part of the array

---

您缺少if语句来检查while之后

i

是否小于或等于

j

public class QuickSort {

public static void display(int[] arr){
    for(int i = 0; i < arr.length; i++) {
        System.out.println( arr[i] );

    }
}

public static void main( String[] args ) {
    int[] data = new int[]{ 5, 10, 1, 9, 4, 8, 3, 6, 2, 6,7 };
    System.out.println("Unsorted array : " );
    display( data );
    quickSort( data, 0, data.length - 1 );
    System.out.println( "Sorted array: " );
    display( data );
}

public static void quickSort( int[] arr, int left, int right ) {
    int i = left;
    int j = right;
    int temp;
    int pivot = arr[( left + right ) / 2];
    while( i <= j ) {
        while( arr[i] < pivot ) {
            i++;
        }
        while( arr[j] > pivot ) {
            j--;
        }
        // You forgot to test here...
        if( i <= j ) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if( left < j ) {
        quickSort( arr, left, j );
    }
    if( i < right ) {
        quickSort( arr, i, right );
    }
}

公共类快速排序{
公共静态无效显示（int[]arr）{
对于（int i=0；iif（i您缺少if语句来检查while之后的
i
是否小于或等于
j

public class QuickSort {

public static void display(int[] arr){
    for(int i = 0; i < arr.length; i++) {
        System.out.println( arr[i] );

    }
}

public static void main( String[] args ) {
    int[] data = new int[]{ 5, 10, 1, 9, 4, 8, 3, 6, 2, 6,7 };
    System.out.println("Unsorted array : " );
    display( data );
    quickSort( data, 0, data.length - 1 );
    System.out.println( "Sorted array: " );
    display( data );
}

public static void quickSort( int[] arr, int left, int right ) {
    int i = left;
    int j = right;
    int temp;
    int pivot = arr[( left + right ) / 2];
    while( i <= j ) {
        while( arr[i] < pivot ) {
            i++;
        }
        while( arr[j] > pivot ) {
            j--;
        }
        // You forgot to test here...
        if( i <= j ) {
            temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }
    if( left < j ) {
        quickSort( arr, left, j );
    }
    if( i < right ) {
        quickSort( arr, i, right );
    }
}

公共类快速排序{
公共静态无效显示（int[]arr）{
对于（int i=0；i如果（i如果您正在执行深度递归调用，您可能希望使用-Xss参数来扩大堆栈大小。您可以在此处找到完整答案：

我知道您的代码有问题，而不是堆栈的实际大小，但一旦您修复了代码，这可能会很有用。
此外，如果您正在执行深度递归调用，您可能希望使用-Xss参数来扩大堆栈大小。您可以在此处找到完整答案：

我知道你的代码有问题，而不是堆栈的实际大小，但一旦你修复了代码，这可能会证明是有用的。
如果（I>=j）{return；}
和
分区（t，I，end）；
完成了任务。
I+1
太多了。我有一段时间没有在这方面进行过实践。谢谢
如果（i>=j{return；}
和
分区（t，i，end）；
完成了任务。
i+1
太多了。我已经有一段时间没有练习过这种事情了。谢谢