Java Algorithms Sort Heap Sort

class Node {
   private int iData; // data item (key)

   public Node(int key) {
      iData = key;// w  ww. j a v  a  2s  .  co m
   }

   public int getKey() {
      return iData;
   }
}

class Heap {
   private Node[] heapArray;
   private int maxSize; // size of array
   private int currentSize; // number of items in array

   public Heap(int mx) {
      maxSize = mx;
      currentSize = 0;
      heapArray = new Node[maxSize];
   }

   public Node remove() {
      Node root = heapArray[0];
      heapArray[0] = heapArray[--currentSize];
      trickleDown(0);
      return root;
   }

   public void trickleDown(int index) {
      int largerChild;
      Node top = heapArray[index]; // save root
      while (index < currentSize / 2) // not on bottom row
      {
         int leftChild = 2 * index + 1;
         int rightChild = leftChild + 1;
         // find larger child
         if (rightChild < currentSize && // right ch exists?
               heapArray[leftChild].getKey() < heapArray[rightChild].getKey())
            largerChild = rightChild;
         else
            largerChild = leftChild;
         // top >= largerChild?
         if (top.getKey() >= heapArray[largerChild].getKey())
            break;
         heapArray[index] = heapArray[largerChild];
         index = largerChild;
      }
      heapArray[index] = top;
   }

   public void displayHeap() {
      int nBlanks = 32;
      int itemsPerRow = 1;
      int column = 0;
      int j = 0;
      String dots = "...............................";
      System.out.println(dots + dots);

      while (currentSize > 0) // for each heap item
      {
         if (column == 0) // first item in row?
            for (int k = 0; k < nBlanks; k++) // preceding blanks
               System.out.print(' ');
         // display item
         System.out.print(heapArray[j].getKey());

         if (++j == currentSize)
            break;

         if (++column == itemsPerRow) {
            nBlanks /= 2; // half the blanks
            itemsPerRow *= 2; // twice the items
            column = 0; // start over on
            System.out.println(); // new row
         } else // next item on row
            for (int k = 0; k < nBlanks * 2 - 2; k++)
               System.out.print(' '); // interim blanks
      }
      System.out.println("\n" + dots + dots); // dotted bottom line
   }

   public void displayArray() {
      for (int j = 0; j < maxSize; j++)
         System.out.print(heapArray[j].getKey() + " ");
      System.out.println("");
   }

   public void insertAt(int index, Node newNode) {
      heapArray[index] = newNode;
   }

   public void incrementSize() {
      currentSize++;
   }
}

public class Main {
   public static void main(String[] args) {
      int size = 10, j;

      Heap theHeap = new Heap(size);

      for (j = 0; j < size; j++) // fill array with
      { // random nodes
         int random = (int) (java.lang.Math.random() * 100);
         Node newNode = new Node(random);
         theHeap.insertAt(j, newNode);
         theHeap.incrementSize();
      }

      System.out.print("Random: ");
      theHeap.displayArray(); 

      for (j = size / 2 - 1; j >= 0; j--)
         theHeap.trickleDown(j);

      System.out.print("Heap:   ");
      theHeap.displayArray();
      theHeap.displayHeap(); 

      for (j = size - 1; j >= 0; j--) // remove from heap and
      { 
         Node biggestNode = theHeap.remove();
         theHeap.insertAt(j, biggestNode);
      }
      System.out.print("Sorted: ");
      theHeap.displayArray(); // display sorted array
   }
}