Почему неправильно работает алгоритм вставки в кучу

Я попробовал написать алгоритм вставки числа в кучу. Идея алгоритма такова:

  1. Вставить размещаемое число в конец массива;
  2. Пока данный элемент (число) больше его радителя, менять их местами. Но почему то этот алгоритм неправильно работает. Вот полный код (обратите внимание на метод add):
public class Main {
  
  public static void main(String[] args) {
    int[] A = new int[] {11, 9, 10, 7, 5, 8, 1};
    Heap myHeap = Heap.buildHeap(A);
    myHeap.add(10);
    myHeap.display();
  }
}
public class Heap {
  private int[] heap;
  private int heapSize;

  protected Heap(int[] heap, int heapSize) {
    this.heap = heap;
    this.heapSize = heapSize;
  }
  
  public static void sort(int[] array) {
  }

  public static Heap buildHeap(int[] array) {
    Heap heap = new Heap(array, array.length);
    for (int i = array.length / 2 - 1; i >= 0; i--) {
      heap.heapify(i);
    }
    return heap;
  }
  
  public void heapify(int i) {
    int l = left(i);
    int r = right(i);
    int largest = i;
    if (l < heap.length && heap[l] > heap[largest]) {
      largest = l;
    }
    if (r < heap.length && heap[r] > heap[largest]) {
      largest = r;
    }
    if (i != largest) {
      swap(i, largest);
      heapify(largest);
    }
  }
  
  public void add(int number) {
    int index = heapSize;
    if (index == heap.length)
      reallocate();
    heap[index] = number;
    int parent = index / 2 - 1;
    while (parent >= 0 && heap[parent] < heap[index]) {
      swap(parent, index);
      index = parent;
      parent = index / 2 - 1;
    }
    heapSize++;
  }
  
  public void reallocate() {
    int[] newHeap = new int[heap.length + 1];
    for (int i = 0; i < heap.length; i++)
      newHeap[i] = heap[i];
    heap = newHeap;
  }
  
  public int right(int i) {
    return 2 * i + 2;
  }
  
  public int left(int i) {
    return 2 * i + 1;
  }
  
  public void swap(int i1, int i2) {
    int temp = heap[i1];
    heap[i1] = heap[i2];
    heap[i2] = temp;
  }
  
  public void display() {
    for (int i = 0; i < heapSize; i++)
      System.out.println(i + ": " + heap[i]);
  }
}


Ответы (1 шт):

Автор решения: Stanislav Volodarskiy

Пусть индекс родителя - 0. Его левый потомок 2 * 0 + 1 = 1. Вычислим родителя по левому потомку: 1 / 2 - 1 = -1. Ошибка.

Формула для индекса родителя должна быть (index - 1) / 2.

→ Ссылка