// PQueue.java: priority queue
public class PQueue {

   private final int qsize;
   private double[] A;
   private int heapsize = 0;

   public PQueue(int s) {
      qsize = s;
      A = new double[qsize];
   }

   public int qSize() { return heapsize; }

   public double heapMaximum() {
      if (heapsize < 1) {
         System.out.println("Empty Queue");
         System.exit(0);
      }
      return A[1];
   }

   public double heapExtractMax() {
      if (heapsize < 1) {
         System.out.println("Heap Underflow");
         System.exit(0);
      }
      double max = A[1];
      A[1] = A[heapsize];
      heapsize--;
      maxHeapify(1);
      return max;
   }

   private int parent(int i) { return i/2; }
   private int left  (int i) { return 2*i; }
   private int right (int i) { return 2*i + 1; }

   private void exchange(int i, int largest) {
      double temp = A[i];
      A[i] = A[largest];
      A[largest] = temp;
   }

   private void maxHeapify(int i) {
      int l = left(i);
      int r = right(i);
      int largest;
      if (l <= heapsize && A[l] > A[i])
         largest = l;
      else largest = i;
      if (r <= heapsize && A[r] > A[largest])
         largest = r;
      if (largest != i) {
         exchange(i, largest); 
         maxHeapify(largest);
      }
   }

   public void maxHeapInsert(double key) {
      if (heapsize >= qsize - 1) {
         System.out.println("Heap Overflow");
         System.exit(1);
      }
      heapsize++;
      A[heapsize] = -1.0e100;
      heapIncreaseKey(heapsize, key);
   }

   void heapIncreaseKey(int i, double key) {
      if (key < A[i]) {
         System.out.println("New key < Current key");
         System.exit(2);
      }
      A[i] = key;
      while (i > 1 && A[parent(i)] < A[i]) {
         exchange(i, parent(i));
         i = parent(i);
      }
   }

   public void printheap() {
      System.out.println("Dump of queue, heapsize:" +
         heapsize);
      for (int i = 1; i <= A.length - 1; i++) {
         System.out.println(i + ": " + A[i]);
      }
      System.out.println();
   }
}

// PqueueTest.java: sort array of random #s
import java.util.*;
public class PQueueTest {
   private Random r;
   private PQueue pQueue;
   private int size;

   public PQueueTest(int size) {
      r = new Random(314159265);
      pQueue = new PQueue(size);
   }

   public void randomTest() {
      for (int i = 0; i < 4; i++) {
         double  ran =  r.nextDouble();
         pQueue.maxHeapInsert(ran);
         System.out.println("Inserted: " + ran);
         pQueue.printheap();
      }
      for (int i = 0; i < 5; i++) {
         double x = pQueue.heapExtractMax();
         System.out.print("Extracted: "+x+", ");
         System.out.println("heapsize: " +
            pQueue.qSize());
      }
   }

   public static void main(String[] args) {
      final int SIZE = 5;
      PQueueTest pq = new PQueueTest(SIZE);
      pq.randomTest();
   }
}
Declared with size=5, so without
A[0], it can hold 4 items. Insert 4, remove 5:
Inserted: 0.28896477417690836
Dump of queue, heapsize:1
1: 0.28896477417690836
2: 0.0
3: 0.0
4: 0.0

Inserted: 0.9560110068247095
Dump of queue, heapsize:2
1: 0.9560110068247095
2: 0.28896477417690836
3: 0.0
4: 0.0

Inserted: 0.12662509646189346
Dump of queue, heapsize:3
1: 0.9560110068247095
2: 0.28896477417690836
3: 0.12662509646189346
4: 0.0

Inserted: 0.6186383705355317
Dump of queue, heapsize:4
1: 0.9560110068247095
2: 0.6186383705355317
3: 0.12662509646189346
4: 0.28896477417690836

Extracted: 0.9560110068247095, heapsize: 3
Extracted: 0.6186383705355317, heapsize: 2
Extracted: 0.28896477417690836, heapsize: 1
Extracted: 0.12662509646189346, heapsize: 0
Heap Underflow