Question

这是我的minHeap算法，但它没有按预期运行：

public static int [] fixheap(int heap[], int n, int i){
    int j=2*i;
    int weight = heap[i];

    while (j<=n){
        if((j<n) && heap[j] > heap[j+1])
            j++;
        if(weight <= heap[j]) break;
        else 
        heap[j/2] = heap[j]; 

        j=j*2;
    }

    heap[j/2]= weight;

    return heap;
}

public static void makeheap(int heap[], int n){

    for (int i=n/2; i>=0; i--){
        fixheap(heap, n ,i);
    }   
}

当以各种顺序添加数据元素时，算法返回不正确的minHeaps。任何人都可以看到这个最小堆算法的任何明显问题吗？

Answer 1

您正在比较数组的错误元素以形成堆。尝试干燥你的程序

当数组从索引0开始时，你应该在这里采用i = n / 2-1。

public static void makeheap(int heap[], int n){

     for (int i=n/2 - 1; i>=0; i--){
     fixheap(heap, n ,i);
    }   
}

然后你必须改变你的fixheap函数来获得j

的正确值

j = i * 2 + 1

Answer 2

我相信你找到父母和/或孩子的方式是不正确的。

考虑一下，如果左边的孩子在index1而右边在index2，我如何在index0找到他们的父母？

如何找到index0的孩子（index1和index2）呢？

Answer 3

下面的代码是在python中，但我会突出显示繁重的行，并且在此过程中希望提供一个创建最小堆的不同解决方案

heapArray = []  
for heapKey in someArray:
    insert(heapArray, int(heapKey))
return heapArray;

def insert(heapArray, heapKey):
  heapArray.append(heapKey)
  index_of_key = len(heapArray)-1
  parent_index_of_key = (index_of_heap_key-1)/2
  while index_of_key>0:
    if(heapKey < heapArray[parent_index_of_key]):
        __swap(index_of_key, parent_index_of_key, heapArray)
        index_of_key = parent_index_of_key;
        parent_index_of_key = (index_of_key-1)/2
    else:
        break # we have reached the right spot

在上面的例子中，我们重新创建堆（是的，这意味着更多的内存，但为了说明的目的，这可能是一个好的开始）。在创建堆时，我们只需检查新插入的键及其父级的值（通过parent_index_of_key）。

如果父项大于其子项，则我们交换该值并更新索引（交换密钥及其新父项）。我们重复这个过程，直到我们到达堆顶部或堆密钥不能进一步向上链

就地互换显然更有效，但上述内容更直观，更易于理解。显然，我不会使用上面的代码，其中内存是一个很大的约束，但是在代码简洁和清晰度超过内存利用率的情况下会考虑它。

最小堆算法

3 个答案: