Java 如何实现堆栈<；E>；withing<；T<；T>>；？
我正在编写的程序是使用堆栈实现为QuickSort类内的快速排序提供一个非递归实现。我觉得我的代码在sort（）方法中是正确的。我遇到的一个问题是由于实现了可比较的接口而初始化堆栈。当我的方法有一个“extends Comparable”时，我的堆栈应该参数化为什么，因为在这种情况下，E是堆栈的错误参数Java 如何实现堆栈<；E>；withing<；T<；T>>；？,java,stack,quicksort,comparable,non-recursive,Java,Stack,Quicksort,Comparable,Non Recursive,我正在编写的程序是使用堆栈实现为QuickSort类内的快速排序提供一个非递归实现。我觉得我的代码在sort（）方法中是正确的。我遇到的一个问题是由于实现了可比较的接口而初始化堆栈。当我的方法有一个“extends Comparable”时，我的堆栈应该参数化为什么，因为在这种情况下，E是堆栈的错误参数 package edu.csus.csc130.spring2017.assignment2; import java.util.Stack; public class Qui
package edu.csus.csc130.spring2017.assignment2;
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<E> stack = new Stack<E>(); //something wrong will <E> i think
stack.push(0);
stack.push(a.length);
while (!stack.isEmpty()) {
int hi = (int) stack.pop();
int lo = (int) stack.pop();
if (lo < hi) {
// everything seems good up til here
int p = partition(a, lo, hi);
stack.push(lo);
stack.push(p - 1);
stack.push(p + 1);
stack.push(hi);
}
}
throw new UnsupportedOperationException();
}
// 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;
}
}
包edu.csus.csc130.spring2017.assignment2；
导入java.util.Stack；
公共类快速排序{
//提供快速排序的非递归版本
//提示：使用堆栈存储中间结果
//可以将java.util.Stack用作堆栈实现
公共静态无效排序（T[]a）{
Stack Stack=new Stack（）；//我会觉得有什么不对劲
堆栈推送（0）；
堆栈推送（a.长度）；
而（！stack.isEmpty（））{
int hi=（int）stack.pop（）；
int lo=（int）stack.pop（）；
如果（低<高）{
//在这里之前一切都很好
INTP=分区（a、lo、hi）；
堆栈推送（lo）；
堆栈推送（p-1）；
堆栈推送（p+1）；
堆栈推送（hi）；
}
}
抛出新的UnsupportedOperationException（）；
}
//划分成a[lo..j-1]，a[j]，a[j+1..hi]
私有静态int分区（T[]a，int-lo，int-hi）{
int i=lo，j=hi+1；//左右扫描索引
tV=a[lo]；//枢轴
while（true）{//向右扫描，向左扫描，检查扫描是否完成，然后交换
而（SortUtils.isLessThan（a[++i]，v））{//++i被计算为i+1
如果（i==hi）{
打破
}
}
而（SortUtils.isLessThan（v，a[--j]）{/--j被计算为j-1
如果（j==lo）{
打破
}
}
如果（i>=j）{
打破
}
交换（a，i，j）；
}
SortUtils.swap（a，lo，j）；//将v=a[j]放置到位
返回j；
}
}
TStackT堆栈TT