C++ 二进制堆-如何以及何时使用max heapify

我正在阅读关于堆数据结构的文章，但我不知道何时使用max heapify函数以及为什么

我编写了一个insert函数，它将始终保持堆为max heap，我看不出何时会使用max heapify

你能解释一下吗？ 多谢各位

这是我的代码：

int父对象（int i）{
返回i/2；
}
左整数（整数i）{
返回2*i；
}
右整数（整数i）{
返回2*i+1；
}
void max_heapify（int*v、int索引、int堆化）{
int最大；
int left=左（索引）；
int right=right（索引）；
if（左v[索引]）
最大=左；
其他的
最大=指数；
如果（右v[最大]）
最大=右；
如果（最大！=索引）{
v[索引]=v[索引]^v[最大]；
v[最大]=v[索引]^v[最大]；
v[索引]=v[索引]^v[最大]；
max_heapify（v，最大，heapsize）；
}
}
无效插入（int*v，int*length，int-value）{
v[++*长度]=值；
int valuePos=*长度；
int parent=parent（valuePos）；
如果（父项！=valuePos）{
而（v[parent]

将数组转换为堆时，应使用heapify算法。您可以通过依次将每个数组元素插入一个新堆来实现这一点，但这需要O（n lg n）个时间，而heapify需要O（n）个时间。max\u heapify预计将在常规数组上调用，以使其成为一个堆。而

insert

执行维护工作，这要求数组（

v

在函数中）已经是一个堆。

您所称的

max heapify

函数是一个通用的

heapify

函数（堆可以使用任何有效的比较函数对其元素进行排序）。它打算用作从数组构造堆的

init

函数

处理堆的函数的复杂性（及其预期用途）：

• init

  （max-heapify）：O（n），用于从排序的序列（数组）初始化堆（在您的示例中为max-sorted）

• insert

  ：O（lg n），用于在堆中插入单个元素（保持堆树“排序”）

• delete

  ：O（lg n），用于从堆中删除“最佳”（在您的情况下为max）元素（维护“排序”的堆树）

但是，由于这个问题被标记为代码> C++ +/COD>，你也应该考虑使用一个从代码> STL< /Cord>来代替实现你自己的堆。所考虑的操作的复杂性与任何堆实现的复杂性相同，并且可以轻松地使用任何比较函数（预写或用户编写）进行操作。相对于堆实现的另一个优点是它是一个排序容器，您可以轻松地按排序顺序遍历所有元素（不仅仅是第一个元素），而不破坏结构

std:：set

的唯一问题是它是一个唯一的容器，也就是说，其中只能存在一个具有相同键的元素副本。但是也有一个解决方案-

std:：multiset

使用相同的键保存多个对象的排序实例

此外，根据您所需的用法（如果有大量数据与搜索键关联），您可能还希望尝试

std:：map

或

std:：multimap

---

如果您想实现自己的堆，我强烈建议您将其放在一个单独的类（甚至是一个名称空间）中，如果您打算充分使用

C++

。如果你只是想保持它的形式，你应该考虑将问题重新标记为<代码> c>代码>

< p>你需要像数组一样随机插入堆中的数据。之后，您可以调用max heapify函数来保留max Heap的属性。这是我的密码

class max_heap{  
 private:               // are the private members of class
      int *arr;
      int size;
      int ind;
};

        void max_heap::bubbledown(int *ar, int i)
        {
         int len = ind - 1;
         int lt = 2 * i;
         int rt = lt + 1;
         while (lt <= len && rt <= len)                                         
         {
            if (arr[i] > arr[lt] && arr[i] > arr[rt])
                break;

            else if (ar[lt] > ar[rt])
            {
                if (ar[i] < ar[lt]){
                    swap(ar[i], ar[lt]);
                    i = lt;
                    lt = 2 * i;
                }
            }
            else if (ar[lt] < ar[rt])
            {
                if (ar[i] < ar[rt]){
                    swap(ar[i], ar[rt]);
                    i = rt;
                    rt = (2 * i)+1;
                }
            }
        }
    }

    void max_heap::heapify()
    {
        int len = ind - 1;
        for (int i = len; i >= 1 && (i/2) >= 1; i--)
        {
            if (arr[i] > arr[i/2])
            {
                swap(arr[i], arr[i/2]);
                bubbledown(arr, i);
            }
        }
    }

class max_heap{
列兵：//是班上的列兵吗
int*arr；
整数大小；
int ind；
};
void max_heap:：bubbledown（int*ar，int i）
{
int len=ind-1；
int lt=2*i；
int-rt=lt+1；
while（lt arr[rt]）
打破
否则如果（ar[lt]>ar[rt]）
{
if（ar[i]=1&&（i/2）>=1；i--）
{
如果（arr[i]>arr[i/2]）
{
掉期（arr[i]，arr[i/2]）；
泡泡镇（arr，i）；
}
}
}

因此，当我试图调用函数将无序数组转换为堆时，我的max_heapify算法出现了问题。但它不起作用。你能给我举个例子吗？我尝试调用max_heapify（v，0，n），但结果不是我的答案中提到的heapAs，may_heapify（）只适用于排序序列。由于在堆中插入元素在某种程度上是对它们进行排序，因此插入必须至少花费O（n lg n）时间-没有更快的排序算法：），但是，您可以使用该函数在O（n）中翻转堆中的排序序列，而使用

insert

函数插入n个元素将始终花费O（n lg n）注意：标准库已经提供了此功能。