Question

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

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

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

解决方案1：

1）堆[I] = K
2）heapify（heap，1）

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

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

所以这里我们交换（55,59）但仍然是min-heap属性将被消除。

解决方案2：

1）用堆[last index]替换heap [i]   2）heapify（堆，1）
  3）现在在堆中插入通常的程序

时间复杂度 - O（log N）
是（解决方案2 ）正确的做法？如果没有，请提供一些hints。

Answer 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;
   }
}

Answer 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

Answer 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

Answer 4

如果它小于它的父亲DecreaseKey（k），否则做MinHeapify（k）

替换min-heap中的元素

4 个答案: