Heap Iterators java

I have this code for a heap tree and I'm stuck with the iterators.

I need in-order, pre-order and post-order iterators, but I have no idea how to do it.

If someone has an idea or example please help.

class Numbers implements Comparable<Numbers> { 
       private int value; 

       public Numbers(int value) { 
          this.value = value; 
       } 

       public String toString() { 
          return Integer.toString(value); 
       } 

       public int getValue() { 
          return this.value; 

   } 

   public int compareTo(Numbers o) { 
      int tmp = o.getValue(); 
      if (value > tmp) 
         return 1; 
      if (value < tmp) 
         return -1; 
      return 0; 
   } 
} 

class BinaryHeapIsFull extends Exception { 
   BinaryHeapIsFull() { 
      super("There is no more place in the heap!"); 
   } 
} 

public class BinaryHeap<E extends Comparable> { 
   E[] elements; 
   int count; 

   public BinaryHeap(int maxSize) { 
      elements = (E[]) new Comparable[maxSize];                                     
      this.count = 0; 
   } 

   public void enqueue(E elem) throws BinaryHeapIsFull { 
      if (count == elements.length) 
         throw new BinaryHeapIsFull(); 

      int i = count++; 
  开发者_StackOverflow中文版    while (i > 0 && elements[(i - 1) / 2].compareTo(elem) == 1) { 
         elements[i] = elements[(i - 1) / 2]; 
         i = (i - 1) / 2; 
      } 
      elements[i] = elem; 
   } 

   public E findMin() { 
      return elements[0]; 
   } 

   public E dequeueMin() { 
      if (count == 0) 
         return null; 
      E result = elements[0]; 

      E last = elements[--count]; 

      int i = 0; 
      while (2 * i + 1 <= count) { 
         int child = 2 * i + 1; 
         if (child < count 
               && elements[child + 1].compareTo(elements[child]) == -1) 
            child++; 
         if (last.compareTo(elements[child]) == -1 
               || last.compareTo(elements[child]) == 0) 
            break; 
         elements[i] = elements[child]; 
         i = child; 
      } 
      elements[i] = last; 
      return result; 
   } 

   public String toString() { 
      String print = ""; 
      for (int i = 0; i < count; i++) 
         print += elements[i].toString() + " "; 
      return print; 
   } 

   public void sort() { 
      int a = count; 
      for (int i = 0; i < a; i++) { 
         System.out.print(findMin() + " "); 
         dequeueMin(); 
      } 
   } 

   public static void main(String[] args) throws BinaryHeapIsFull { 
      BinaryHeap<Numbers> b = new BinaryHeap<Numbers>(10); 
      b.enqueue(new Numbers(6)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(3)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(4)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(1)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(5)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(0)); 
      System.out.println(b.toString()); 
      b.enqueue(new Numbers(2)); 
      System.out.println(b.toString()); 
      b.dequeueMin(); 
      System.out.println(b.toString()); 
      b.dequeueMin(); 
      System.out.println(b.toString()); 
      System.out.println(b.findMin()); 
      b.sort(); 

   } 
} 

I'd start with three classes, one for each case, that implements the Iterator interface. Give those iterators an instance of your binary heap and let them do their thing.

public class BinaryHeapPreOrderIterator implements Iterator {
   // constructor and methods for Iterator here.
}