替换最小堆中的元素答案

【问题标题】：replacing element in min-heap替换最小堆中的元素
【发布时间】：2013-12-22 06:09:05
【问题描述】：

这个问题。在电话采访中被问到我的朋友。

实现一个函数，将索引i处的元素替换为k，在最小堆中并重新排列堆。

这是我的解决方案，请告诉我是否正确。

解决方案 1：

1)堆[i]=k
2）堆（堆，1）

但这似乎是错误的，因为在这种情况下：

  10
 /  \
14  59 (<-was 12 before replacing)
.. /  \
  55  20

所以我们在这里交换（55,59），但仍然会破坏最小堆属性。

解决方案 2：

1)用堆[最后一个索引]替换堆[i]
2) heapify(堆, 1)
3) 现在像往常一样在堆中插入过程

时间复杂度 - O(log N)
它（解决方案 2）是正确的方法吗？如果没有请给一些hints。

【问题讨论】：

解决方案 2 是要走的路，imo。它有效并且非常有效。

标签： algorithm data-structures heap

【解决方案1】：

类似解决方案 1 的方法可能更好。

heap[i] = k
如果heap[i] 小于其父级，则将其冒泡（游泳）
否则，如果heap[i] 比它的一个孩子大，则将其冒泡（下沉）

运行时间：O(log n).

游泳 - 当它比它的父母小时，把它和它的父母交换。

下沉 - 当它比它的一个孩子大时，把它换成它最小的孩子。

sink 和 swim 的一些 Java 代码，取自 here：

private void swim(int k) {
   while (k > 1 && less(k/2, k)) {
      exch(k, k/2);
      k = k/2;
   }
}

private void sink(int k) {
   while (2*k <= N) {
      int j = 2*k;
      if (j < N && less(j, j+1)) j++;
      if (!less(k, j)) break;
      exch(k, j);
      k = j;
   }
}

【讨论】：

【解决方案2】：

这是O(logn)中的一种方法

以下操作的伪代码：-

void replaceHeap(int index,int value) {

  heap[index] = value;
  BubbleUp(index);

  Heapify(index);


}

void BubbleUp(int index) {

   parent = index/2;

   while(index>1&&heap[parent]>heap[index]) {

         swapElementAt(parent,index);
         index = parent;
         parent = index/2;
   }

}

Heapify is standard as you have done it

【讨论】：

【解决方案3】：

为了简单起见，这是python中最简单的实现。

# Replace item
self.heap[index] = something_new

# Get left child
try:
    left_child = self.heap[2 * index + 1]
except IndexError:
    left_child = None

# Get right child
try:
    right_child = self.heap[2 * index + 2]
except IndexError:
    right_child = None

# Get parent
parent = self.heap[int(math.floor(index / 2))]

# If smaller than parent, swim up
if parent is not None and self.heap[index] < parent:
    swim(index)
    break

# If larger than one of its children sink
if left_child is not None:
    if self.heap[index] > left_child:
        sink(index)
        break

if right_child is not None:
    if self.heap[index] > right_child:
        sink(index)
        break

【讨论】：

【解决方案4】：

如果它小于 DecreaseKey(k) 的父级，则执行 MinHeapify (k)

【讨论】：

DecreaseKey(k) 是什么？
p = parent(k); while (valid_index (p) && a[k]