修复最大堆插入操作中的Heapify错误：父节点索引与根节点处理

// 辅助方法
private int getLeftChildIndex(int index) { return (2*index + 1); }
private int getLeftChildValue(int index) { return heap[2*index + 1]; }
private int getRightChildIndex(int index) { return (2*index + 2); }
private int getRightChildValue(int index) { return heap[2*index + 2]; }

private int getParentIndex(int index) {
    return ((int) Math.ceil((index - 2)/2)); // 问题点1
}

private void swap(int child, int parent) {
    int temp = heap[parent];
    heap[parent] = heap[child];
    heap[child] = temp;
}

// 插入方法
private void insert(int num) {
    heap[heapSize] = num;
    heapSize++;
    int index = heapSize - 1;
    while (getParentIndex(index) > 0 && heap[index] > heap[getParentIndex(index)]) { // 问题点2
        swap(index, getParentIndex(index));
        index = getParentIndex(index);
    }
}

private int getParentIndex(int index) {
    return (index - 1) / 2; // 修正后的父节点索引计算
}

private void insert(int num) {
    heap[heapSize] = num;
    heapSize++;
    int index = heapSize - 1; // 新插入元素的当前索引

    // 循环条件：当前元素不是根节点（index > 0），并且当前元素大于其父节点
    while (index > 0 && heap[index] > heap[getParentIndex(index)]) {
        swap(index, getParentIndex(index));
        index = getParentIndex(index); // 更新当前元素的索引到其新的位置
    }
}

public class MaxHeap {
    private int[] heap;
    private int heapSize;
    private static final int DEFAULT_CAPACITY = 10; // 假设有一个默认容量

    public MaxHeap() {
        this.heap = new int[DEFAULT_CAPACITY];
        this.heapSize = 0;
    }

    // 辅助方法：获取左子节点索引
    private int getLeftChildIndex(int index) {
        return (2 * index + 1);
    }

    // 辅助方法：获取右子节点索引
    private int getRightChildIndex(int index) {
        return (2 * index + 2);
    }

    // 修正后的辅助方法：获取父节点索引
    private int getParentIndex(int index) {
        if (index == 0) return -1; // 根节点没有父节点
        return (index - 1) / 2;
    }

    // 辅助方法：交换两个元素
    private void swap(int index1, int index2) {
        int temp = heap[index1];
        heap[index1] = heap[index2];
        heap[index2] = temp;
    }

    // 修正后的插入方法
    public void insert(int num) {
        // 检查是否需要扩容，这里简化为假设容量足够
        if (heapSize == heap.length) {
            System.out.println("Heap is full. Cannot insert more elements.");
            return;
        }

        heap[heapSize] = num; // 将新元素添加到堆的末尾
        int currentIndex = heapSize; // 新元素的当前索引
        heapSize++; // 堆大小增加

        // 执行上浮操作 (heapify)
        // 循环条件：当前元素不是根节点 (currentIndex > 0)，
        // 并且当前元素大于其父节点
        while (currentIndex > 0 && heap[currentIndex] > heap[getParentIndex(currentIndex)]) {
            int parentIndex = getParentIndex(currentIndex);
            swap(currentIndex, parentIndex);
            currentIndex = parentIndex; // 更新当前元素的索引到其新的位置
        }
    }

    // 示例：获取堆数组内容（仅用于调试和演示）
    public int[] getHeapArray() {
        int[] result = new int[heapSize];
        System.arraycopy(heap, 0, result, 0, heapSize);
        return result;
    }

    public static void main(String[] args) {
        MaxHeap heap = new MaxHeap();
        heap.insert(15);
        System.out.println("After 15: " + java.util.Arrays.toString(heap.getHeapArray())); // [15]
        heap.insert(5);
        System.out.println("After 5: " + java.util.Arrays.toString(heap.getHeapArray()));  // [15, 5]
        heap.insert(10);
        System.out.println("After 10: " + java.util.Arrays.toString(heap.getHeapArray())); // [15, 5, 10]
        heap.insert(30);
        System.out.println("After 30: " + java.util.Arrays.toString(heap.getHeapArray())); // [30, 15, 10, 5]

        // 预期输出: [30, 15, 10, 5]
    }
}