Comment implémenter la pile <E> avec <T extends Comparable <T>>?

Question

Le programme que j'écris est de fournir une implémentation non récursive pour le tri rapide dans la classe QuickSort en utilisant une implémentation de pile. Je pense que mon code est correct dans la méthode sort(). Un problème que j'ai est avec l'initialisation Stack en raison de l'implémentation de l'interface Comparable. Quand ma méthode a une extension "Comparable" Que dois-je paramétrer ma pile puisque E est le mauvais paramètre pour Stack dans cette situation.

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; 
     } 

    } 

Answer 1

Vous allez pousser et Entiers pop sans relation avec votre type T, de sorte que vous voulez probablement utiliser Stack<Integer>.