最大堆学习笔记

学习目标：

最大堆

---

学习内容：

优先队列：特殊的“队列”，取出元素的顺序是依照元素的优先权（关键字）大小，而不是元素进入队列的顺序。 优先队列的实现方法：采用数组、链表、二叉树

1. 数组：
   插入——元素总是插入尾部 O(1)
   删除——查找最大或最小的关键字 O(n）
   从数组中删去需要移动元素 O(n)

2. 链表：
   插入——元素总是插入链表的头部 O(1）
   删除——查找最大（最小）关键字 O(n）
   删除节点 O(1)

3. 有序数组：
   插入——找到合适的位置 O（n）或者O（logn）
   移动元素并插入 O(n）
   删除——删除最后一个元素 O(1)

4. 有序链表
   插入——找到合适的位置 O（n）或者O（logn）
   移动元素并插入 O(1）
   删除——删除尾元素或首元素 O(1)

5. 堆
   结构性：用数组表示的完全二叉树
   有序性：任意节点的关键字是其子树所有节点的最大（最小）值

---

最大堆的操作（创建、插入、删除）

1. 最大堆的创建
typedef struct HeapStruct *MaxHeap;
struct HeapStruct{
ElementType *Elements; //存储堆元素的数组
int Size; //堆得当前元素总数
int Capacity; //堆的最大容量
}；
//创建容量为MaxSize的空的堆
MaxHeap Create(int MaxSize)
{
MaxHeap H = malloc(sizeof(struct HeapStruct));
H->Elements = malloc((MaxSize+1)*sizeof(ElementType));
H->Size = 0;
H->Capacity = MaxSize;
//定义哨兵
H->Elements[0] = MaxData; //哨兵的值大于所有元素的值
return H;
}
2.插入:将新增的结点插入其父节点从下往上到根节点的有序序列中
bool IsFull(MaxHeap H)
{
return (H->Size==H->Capacity);
}

bool Insert(MaxHeap H, ElementType item)
{
int i;
if(IsFull(H))
{
printf(“最大堆已经满了”);
return false;;
}
i = ++H->Size; //Size+1;
for(;H->Elements[i/2]<item;i/=2)
{
H->Elements[i] = H->Elements[i/2];
}
H->Elements[i] = item;
return true;
}
3.删除最大值
bool IsEmpty(MaxHeap H)
{
return (H->Size==0）；
}

ElementTpye Delete（MaxHeap H）
{
int Parent,Child;
ElementType MaxItem,X;

if(IsEmpty(H) return ERROR;
MaxItem = H->Elements[1];

X = H->Elements[H->Size–];
for(Parent = 1; Parent * 2 < H->Size;Parent = Child)
{
Child = Parent *2 ;
if(Child != H->Size&&(H->Elements[Child] < H->Elements[Child + 1])
{
child ++；
}
if（X > H->Elements[Child]) break;
else
{
H->Elements[Parent] = H->Elements[Child];
}
}
H->Elements[Parent] = X;
return MaxIten;
}
4.最大堆的建立
如何将已经存在的N个元素按最大堆的要求存放在一个数组中。
方案一：利用最大堆的插入操作将N个元素相续插入到一个初始为空的堆里，O（NlogN）.
方案二：将N个元素按输入顺序存入二叉树，需要满足完全二叉树的结构特征，但不需要管有序性；
调整各节点元素，以满足最大堆的有序特征（删除结点思想）。
void PercDow（MaxHeap H, int p）
{
int Parent,Child;
ElementType MaxItem,X;

X = H->Elements[p];
for(Parent = p; Parent * 2 < H->Size;Parent = Child)
{
Child = Parent *2 ;
if(Child != H->Size&&(H->Elements[Child] < H->Elements[Child + 1])
{
child ++；
}
if（X > H->Elements[Child]) break;
else
{
H->Elements[Parent] = H->Elements[Child];
}
}
H->Elements[Parent] = X;
}

void BuildHeap(MaxHeap H)
{
int i;
for(i = H->Size/2;i>0;i++)
{
PercDown(H,i);
}
}