Java 迭代快速排序

我正在尝试实现一个迭代运行的快速排序方法。我用堆栈保存信息。它还将使用分区来实现这一点。我知道代码底部的分区部分很好，只是第一块代码有问题。然而，出于某种原因，我的代码并没有做它应该做的事情。没有太多的java经验，所以如果有人看到任何会抛出标志的错误，我们将不胜感激

import java.util.Stack;

public class QuickSort{

// provide non-recursive version of quick sort
// hint: use stack to stored intermediate results
// java.util.Stack can be used as stack implementation
public static <T extends Comparable<T>> void sort(T[] a) {
    Stack<Integer> stack = new Stack<Integer>();

      stack.push(0);
      stack.push(a.length);

      while (!stack.isEmpty())
      {
         int i = 0; 
         int hi = a[i]
         hi = stack.pop();
         int lo = stack.pop();

         if (hi - lo < 2) {
             continue;
             }


         int j = partition(a, lo, hi);
         j = hi + ((lo - hi) / 2);

         stack.push(j - 1);
         stack.push(hi);
         stack.push(lo);
         stack.push(j);    

      } 
         // return;
}

//THIS SECTION OF CODE BELOW SHOULD BE FINE 

// Partition into a[lo..j-1], a[j], a[j+1..hi]
private static <T extends Comparable<T>> int partition(T[] a, int lo, int hi) { 
    int i = lo, j = hi + 1; // left and right scan indices
    T v = a[lo]; // the pivot

    while (true) { // Scan right, scan left, check for scan complete, and exchange
        while (SortUtils.isLessThan(a[++i], v)) {//++i is evaluated to i+1 
            if (i == hi) {
                break;
            }
        }
        while (SortUtils.isLessThan(v, a[--j])) {//--j is evaluated to j-1
            if (j == lo) {
                break;
            }
        }
        if (i >= j) {
            break;
        }

        SortUtils.swap(a, i, j);
    }

    SortUtils.swap(a, lo, j); // Put v = a[j] into position
    return j; 
}

}

由于in partition（）

hi

是数组最后一个元素的索引，因此在代码的初始部分，第二个push应该是push（a.length-1），即

last

索引，而不是

end

索引。此外，if应检查hi-lo是否小于1

---

调用partition后，j=现在排序的pivot的索引。j=hi+的行。。。应删除，因为partition（）返回用于j的值。由于[j]已排序，因此不应将其包含在要递归处理的两个分区中。需要修复两条stack.push（j…）线。

欢迎使用stack Overflow！看起来您需要学习使用调试器。请随便吃点。如果您以后仍然有问题，请随时提供更多详细信息。为什么要迭代地实现快速排序，但要依赖堆栈类来实现呢？当您递归地调用QuickSort时，它隐式地使用堆栈，但代码会更干净，并且可能比您的版本运行得稍快。如果这是一种学术练习，看看你是否能做到，酷。如果你这样做是因为你认为迭代总是比递归快，那是不正确的，你应该坚持递归。@ScottK因为这是一个学校作业，我认为（至少部分）目的是使隐式堆栈显式化。

package edu.csus.csc130.spring2017.assignment2;

import java.util.Arrays;

import org.junit.Assert;
import org.junit.Test;

public class 

QuickSortTest {

@Test
public void testSort1() {
    Integer[] a = {17};
    Integer[] expected = {17};
    QuickSort.sort(a);
    System.out.println(Arrays.toString(a));
    Assert.assertArrayEquals(expected, a);
}

@Test
public void testSort2() {
    Integer[] a = {17, 5};
    Integer[] expected = {5, 17};
    QuickSort.sort(a);
    System.out.println(Arrays.toString(a));
    Assert.assertArrayEquals(expected, a);
}

@Test
public void testSort3() {
    Integer[] a = {64, 18, 74, 89, 58, 17, 48, 44, 92, 88, 78, 80, 75, 25, 77, 18, 39, 95, 11, 2};
    Integer[] expected = {2, 11, 17, 18, 18, 25, 39, 44, 48, 58, 64, 74, 75, 77, 78, 80, 88, 89, 92, 95};
    QuickSort.sort(a);
    System.out.println(Arrays.toString(a));
    Assert.assertArrayEquals(expected, a);
}


}