Aufbau einer min-heap mit java

Einfügen :
Beim einfügen in einen min-heap, beginnen wir, indem Sie das element an der Unterseite. Wir legen an der
der niedrigstwertigen Stelle, damit der komplette Baum-Eigenschaft.
Dann werden wir ein "Update" der Baum durch vertauschen das neue element mit seinen Eltern, bis wir eine geeignete Stelle für
das element. Wir im wesentlichen Blase bis das minimale element.
Dies dauert 0 (log n) Zeit, wobei n die Anzahl der Knoten im heap.

Extrakt Minimale Element :
Finden des minimalen Elements in einem min-heap ist einfach: es ist immer an der Spitze. Der schwierigste Teil ist, wie zu entfernen
es. (I n der Tat, dies ist nicht so schwierig.)
Zuerst entfernen wir das minimale element und tausche es mit dem letzten element im heap (die untersten,
am weitesten rechts stehenden element). Dann, wir bubble down element, tauschen es mit einem seiner Kinder, bis die minheap
- Eigenschaft wiederhergestellt ist.
Wir vertauschen es mit dem linken Kind oder das Rechte Kind? Das hängt davon ab, Ihre Werte. Es gibt keine inhärente
die Bestellung zwischen dem linken und rechten element, aber Sie müssen nehmen Sie die kleinere in Ordnung zu halten
die min-heap-Bestellung.

public class MinHeap {

    private int[] heap;
    private int size;
    private static final int FRONT = 1;

    public MinHeap(int maxSize) {
      heap = new int[maxSize + 1];
      size = 0;
    }

    private int getParent(int position) {
      return position / 2;
    }

    private int getLeftChild(int position) {
      return position * 2;
    }

    private int getRightChild(int position) {
      return position * 2 + 1;
    }

    private void swap(int position1, int position2) {
      int temp = heap[position1];
      heap[position1] = heap[position2];
      heap[position2] = temp;
    }

    private boolean isLeaf(int position) {
      if (position > size / 2) {
        return true;
      }
      return false;
    }

    public void insert(int data) {
      heap[++size] = data;
      int currentItemIndex = size;
      while (heap[currentItemIndex] < heap[getParent(currentItemIndex)]) {
        swap(currentItemIndex, getParent(currentItemIndex));
        currentItemIndex = getParent(currentItemIndex);
      }
    }

    public int delete() {
      int item = heap[FRONT];
      swap(FRONT, size--); //heap[FRONT] = heap[size--];
      heapify(FRONT);
      return item;
    }

    private void heapify(int position) {
      if (isLeaf(position)) {
        return;
      }
      if (heap[position] > heap[getLeftChild(position)]
          || heap[position] > heap[getRightChild(position)]) {
        //if left is smaller than right
        if (heap[getLeftChild(position)] < heap[getRightChild(position)]) {
          //swap with left
          swap(heap[position], heap[getLeftChild(position)]);
          heapify(getLeftChild(position));
        } else {
          //swap with right
          swap(heap[position], heap[getRightChild(position)]);
          heapify(getRightChild(position));
        }
      }
    }

    @Override
    public String toString() {
      StringBuilder output = new StringBuilder();
      for (int i = 1; i <= size / 2; i++) {
        output.append("Parent :" + heap[i]);
        output
            .append("LeftChild : " + heap[getLeftChild(i)] + " RightChild :" + heap[getRightChild(i)])
            .append("\n");
      }
      return output.toString();
    }

    public static void main(String... arg) {
      System.out.println("The Min Heap is ");
      MinHeap minHeap = new MinHeap(15);
      minHeap.insert(5);
      minHeap.insert(3);
      minHeap.insert(17);
      minHeap.insert(10);
      minHeap.insert(84);
      minHeap.insert(19);
      minHeap.insert(6);
      minHeap.insert(22);
      minHeap.insert(9);

      System.out.println(minHeap.toString());
      System.out.println("The Min val is " + minHeap.delete());
    }
  }