优先队列 - 1

1
2 9 11 6
3 7
8
4
10
5
34
9.3.4 最大堆的初始化
1
2 9 11 6
7 3
8
4
10
5
35
9.3.4 最大堆的初始化
1
2 9 11 6
7 3
8
4
10
5
36
9.3.4 最大堆的初始化
1
11
9 6
7 3
8
4
10
5
为 2 找位置
37
9.3.4 最大堆的初始化
1
11
9 10 6
7 3
8
4
5
为 2 找位置
38
9.3.4 最大堆的初始化
1
11
9 10 6
7 3
8Hale Waihona Puke 42539
9.3.4 最大堆的初始化
1
11 9 10 6
7 3
8
4
2
5
40
9.3.4 最大堆的初始化
11
7 9 10 6 3
8
4
2
5
为 1 找位置
41
9.3.4 最大堆的初始化
11
10 9 6
7 3
8
4
2
5
为 1 找位置
“查找/删除”操作用来“搜索/删除”优先权最 大的元素。
优先权队列中的元素可以有相同的优先权。
5
最大优先权队列的抽象数据类型描述
抽象数据类型 MaxPriorityQueue{ 实例 有限的元素集合，每个元素都有一个优先权 操作 Create()：创建一个空的优先队列 Size()：返回队列中的元素数目 Max()：返回具有最大优先权的元素 Insert(x)：将x插入队列 DeleteMax(x)：从队列中删除具有最大优先权的元素， 并将该元素返回至x }

26
9.3.4 最大堆的初始化
1. 通过在初始化为空的堆中执行n次插入
操作来构造。

O(nlog2n)
更快的堆的初始化策略？ 2. 通过必要时对树进行调整的方法构造。

(n)
27
思想

从第一个具有孩子的节点开始，
这个元素在数组中的位置为i=[n/2]
如果以这个元素为根的子树已是最大堆，则此 时不需调整
采用有序线性表描述最大优先队列


公式化描述（利用公式Location(i)=i-1，元素按递增次序 排列) 插入: O(n) ;删除: O(1) ; 使用链表（按递减次序排列） 插入: O(n) ;删除: O(1) ; 8
9.3 堆(Heaps)
9.3.1 定义 定义[最大树（最小树）] 每个节点的值
16
9.3.2 最大堆的插入
9 20 7
6
5 1 7
8
2
6
17
9.3.2 最大堆的插入
20 9 7
6
5 1 7
8
2
6
18
9.3.2 最大堆的插入
插入的时间复杂性:

每一层的工作，耗时：(1) 实现插入策略的时间复杂性为：O(height) = O(log2n), （ n 是堆的大小）
19
9.3.3 最大堆的删除
20 15 6 5 1 7 9 8 2 7 6
最大元素在根上。
20
9.3.3 最大堆的删除
15
7
6
5 1 7
9
8
2
6
最大元素被删除以后
21
9.3.3 最大堆的删除
15
7
6
5 1 7
9
8
2
6
具有10个节点的堆. 在堆中重新插入8 .
22
9.3.3 最大堆的删除
8 15 6 9 2 7 6
否则必须调整子树使之成为堆。


随后，继续检查以i-1,i-2等节点为根的 子树 直到检查到整个二叉树的根节点（其位置 为1）。
28
8/16/2015
9.3.4 最大堆的初始化
例: 输入数组 = [1,2,3,4,5,6,7,8,9,10,11]
1
2
3
4
5
6
7
8
9
10
11
29
9.3.4 最大堆的初始化
}
}
heap[c/2] = y;
// heap[c] 应是较大的同胞节点 if (c < CurrentSize && heap[c] < heap[c+1]) c++; //能把y放入heap[c/2]吗? if (y >= heap[c]) break; // 能 // 不能 heap[c/2] = heap[c]; // 将孩子上移 c *= 2; // 下移一层 }
从数组中最右一个有孩子的节点开始 这个元素的位置
i= n/2 .
1
2
3
4
5
6
7
8
9
10
11
30
9.3.4 最大堆的初始化
1
2 4 11 6
3
7
8
9
10
5
31
9.3.4 最大堆的初始化
1
2 4 11 6
3
7
8
9
10
5
32
9.3.4 最大堆的初始化
1
2 9 11 6
3 7
8
4
10
5
33
9.3.4 最大堆的初始化
5
1
7
需要进行调整（或重构）。左子树和右子树是最大堆
23
9.3.3 最大堆的删除
15 8 6 5 1 7 9 2 7 6
24
9.3.3 最大堆的删除
15 9 6 5 1 7 8 2 7 6
25
9.3.3 最大堆的删除
删除的时间复杂性:
删除的时间复杂性与插入的时间复杂性相同. 每一层的工作，耗时：(1) 实现删除策略的时间复杂性为：O(height) = O(log2n), （ n 是堆的大小）
{// 构造函数
MaxSize = MaxHeapSize; heap = new T[MaxSize+1]; CurrentSize = 0;
}
48
最大堆的插入
template<class T> MaxHeap<T>& MaxHeap<T>::Insert(const T& x) {//把x插入到最大堆中 if (CurrentSize==MaxSize) throw NoMem(); //为x寻找相应插入位置 //i从新的叶节点开始，并沿着树上升 int i=++CurrentSize； while (i!=1 && x>heap[i/2]){ //不能把x放入heap[i] heap[i]=heap[i/2]; i/=2; } heap[i]=x; return *this; }
8/16/2015 51
void MaxHeap<T>::Initialize(T a[], int size, int ArraySize) {// 把数组a初始化为最大堆. delete [] heap; heap = a; CurrentSize = size; MaxSize = ArraySize; // 产生一个最大堆 for (int i = CurrentSize/2; i >= 1; i--) { T y = heap[i]; // 子树的根 // 寻找放置y的位置 int c = 2*i; // c的父节点是y的目标位置 while (c <= CurrentSize) {
8/16/2015 49
最大堆的删除（1/2）
template<class T> MaxHeap<T>& MaxHeap<T>::DeleteMax(T& x)
{//将最大元素放入x，并从堆中删除最大元素
//检查堆是否为空 if (CurrentSize==0) throw OutOfBounds(); //队列空 x=heap[1];//最大元素 //重构堆 T y=heap[CurrentSize--];//最后一个元素
//从根开始，为y寻找合适的位置
int i=1, //堆的当前节点 ci=2;//i的孩子
8/16/2015 8/16/2015 50
最大堆的删除（2/2）
while (ci<=CurrentSize) { //heap[ci]应该是i较大的孩子 if(ci<CurrentSize && heap[ci]<heap[ci+1]) ci++; //能把y放入heap[i]吗？ if (y>=heap[ci]) break; //能 //不能 heap[i]=heap[ci]; i=ci; ci*=2; } heap[i]=y; return *this; }
堆是完全二叉树，可用一维数组有效地描述堆.
9
8 6 7 2
7 6
5
heap
1
9 8 7 6 7 2 6 5 1 0 1 2 3 4 5 6 7 8 9 10
currentsize
……
Maxsize
47
MaxHeap构造函数
template<class T>
MaxHeap<T>::MaxHeap(int MaxHeapSize)