Question

由于某些奇怪的原因，我需要多次运行我的heapify函数才能返回正确的堆数组。我对递归函数不是很好，我试图用手写它并追踪我的函数，但有时候我迷路了。

#include <iostream>

using namespace std;

void heapSort(int array[], size_t size);
void heapify(int array[], size_t gIndex, size_t size);
size_t left(size_t index);
size_t right(size_t index);
size_t parent(size_t index);

int main(){
    static const size_t SIZE = 9;
    int arr[] = { 13, 14, 15, 18, 11, 12, 17, 16, 90};
    heapify(arr, 0, SIZE);
    //heapify(arr, 0, SIZE);
    //heapify(arr, 0, SIZE);

    cout << "---\n";
    for (size_t i = 0; i < SIZE; i++){
        cout << arr[i] << endl;
    }
    return 0;
}

size_t left(size_t index){
    return (2 * index) + 1;
}
size_t right(size_t index){
    return (2 * index) + 2;
}
size_t parent(size_t index){
    return (index - 1) / 2;
}
void heapify(int array[], size_t gIndex, size_t size){
    size_t index = gIndex;
    int head = array[index];
    int xright = array[right(index)];
    int xleft = array[left(index)];

    if ((left(index) >= size )){
        return;
    }
    else if (head < xleft){
        array[index] = xleft;
        array[left(index)] = head;
        heapify(array, index, size);
    }
    else if (head < xright){
        array[right(index)] = head;
        array[index] = xright;
        heapify(array, index, size);

    }
    else if (head > xright && head > xleft){
        size_t newind = gIndex + 1;
        heapify(array, newind, size);
    }


}


void heapSort(int array[], size_t size){

}

Answer 1

逐行阅读heapify：

int xright = array[right(index)];
int xleft = array[left(index)];

这里你没有数组范围，因为索引可能大于size / 2。所以你已经有了未定义的行为，但实际上这会将xright和xleft崩溃或初始化为一些垃圾值。

if ((left(index) >= size )){
    return;
}

如果left(index) == size - 1执行继续，但在这种情况下right(index) == size。所以你在xright中有垃圾，之后你将它分配给array[index]，从而带来一些垃圾值。同样在这里：array[right(index)] = head你在数组边界外写，因此再次表现出未定义的行为（好像一次是不够的）。

<强>更新
实际上你总体上做错了。首先，您应为heapify和left(index)调用right(index)（如果有的话）。因此，您在左右位置具有最大的左右子树。然后找到array[index]，array[left(index)]和array[right(index)]的最大值，并将其与array[index]交换。

Heapify需要多次运行

1 个答案: