هیپ در جاوا (heap implementation)

   private boolean less(int i, int j) {
              return ((Comparable<Key>) pq[i]).compareTo(pq[j]) < 0;

     }
     private void exch(int i, int j) {
          Key swap = pq[i];
          pq[i] = pq[j];
          pq[j] = swap;
     }

 private void swim(int k) {
          while (k > 1 && less(k / 2, k)) {
              exch(k, k / 2);
              k = k / 2;
          }
     }

  private void sink(int k) {
          while (2 * k <= N) {
              int j = 2 * k;
              if (j < N && less(j, j + 1))
                   j++;
              if (!less(k, j))
                   break;
              exch(k, j);
              k = j;
          }
     }

public void insert(Key x) {

if (N >= pq.length - 1)
resize(2 * pq.length);

pq[++N] = x;
swim(N);

}

public Key delMax() {
if (isEmpty())
throw new NoSuchElementException("Priority queue underflow");
Key max = pq[1];
exch(1, N--);
sink(1);
pq[N + 1] = null; // to avoid loiterig and help with garbage collection
if ((N > 0) && (N == (pq.length - 1) / 4))
resize(pq.length / 2);
return max;
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Spliterator;
import java.util.function.Consumer;

public class MaxHeap<Key> implements Iterable<Key> {
     private Key[] pq; // store items at indices 1 to N
     private int N; // number of items on priority queue


     public MaxHeap(int capacity) {
          pq = (Key[]) new Object[capacity + 1];
          N = 0;
     }



     public MaxHeap() {
          this(1);
     }

     public boolean isEmpty() {
          return N == 0;
     }

     public int size() {
          return N;
     }

     public Key max() {
          if (isEmpty())
              throw new NoSuchElementException("Priority queue underflow");
          return pq[1];
     }

     private void resize(int capacity) {
          assert capacity > N;
          Key[] temp = (Key[]) new Object[capacity];
          for (int i = 1; i <= N; i++)
              temp[i] = pq[i];
          pq = temp;
     }

     public void insert(Key x) {

          if (N >= pq.length - 1)
              resize(2 * pq.length);

          pq[++N] = x;
          swim(N);

     }

     public Key delMax() {
          if (isEmpty())
              throw new NoSuchElementException("Priority queue underflow");
          Key max = pq[1];
          exch(1, N--);
          sink(1);
          pq[N + 1] = null; // to avoid loiterig and help with garbage collection
          if ((N > 0) && (N == (pq.length - 1) / 4))
              resize(pq.length / 2);
          return max;
     }

     private void swim(int k) {
          while (k > 1 && less(k / 2, k)) {
              exch(k, k / 2);
              k = k / 2;
          }
     }

     private void sink(int k) {
          while (2 * k <= N) {
              int j = 2 * k;
              if (j < N && less(j, j + 1))
                   j++;
              if (!less(k, j))
                   break;
              exch(k, j);
              k = j;
          }
     }

     private void exch(int i, int j) {
          Key swap = pq[i];
          pq[i] = pq[j];
          pq[j] = swap;
     }

     // is pq[1..N] a max heap?
     private boolean isMaxHeap() {
          return isMaxHeap(1);
     }

     // is subtree of pq[1..N] rooted at k a max heap?
     private boolean isMaxHeap(int k) {
          if (k > N)
              return true;
          int left = 2 * k, right = 2 * k + 1;
          if (left <= N && less(k, left))
              return false;
          if (right <= N && less(k, right))
              return false;
          return isMaxHeap(left) && isMaxHeap(right);
     }

     private boolean less(int i, int j) {
              return ((Comparable<Key>) pq[i]).compareTo(pq[j]) < 0;

     }

     public Iterator<Key> iterator() {
          return new HeapIterator();
     }

     private class HeapIterator implements Iterator<Key> {

          // create a new pq
          private MaxHeap<Key> copy;

          // add all items to copy of heap
          // takes linear time since already in heap order so no keys move
          public HeapIterator() {
              copy = new MaxHeap<Key>(size());

              for (int i = 1; i <= N; i++)
                   copy.insert(pq[i]);
          }

          public boolean hasNext() {
              return !copy.isEmpty();
          }

          public void remove() {
              throw new UnsupportedOperationException();
          }

          public Key next() {
              if (!hasNext())
                   throw new NoSuchElementException();
              return copy.delMax();
          }
     }

     public static void main(String[] args) {
          MaxHeap<String> pq = new MaxHeap<String>();

          String list[] ={"A","B","C","D","E"};
          for (int i = 0; i < list.length; i++) {
              pq.insert(list[i]);
          }

          Iterator it = pq.iterator();
          while (it .hasNext()) {
              String type = (String) it.next();
              System.out.println(type);

          }

     }

}