第六章 优先级队列

Priority queue applications

Event-driven simulation. Numerical computation. Data compression. Graph searching. Number theory. Artificial intelligence. Statistics. Operating systems. Discrete optimization. Spam filtering.
2
1
h = log N +1
3
Array Representation : BT [ n + 1 ] ( BT [ 0 ] is not used)
4
B D A
5 10
F
6 BT 11 12
G C
0
7
1 A 8 H
2 B 9 I
3 C 10 J
4 D 11
5 E 12
6 F 13
8
E
9
13 14
// 向上过滤
int hole = ++currentSize; for( ; hole > 1 && x < array[ hole / 2 ]; hole /= 2 ) //在x
大于空结点的父结点或已过滤到根时终止循环
array[ hole ] = array[ hole / 2 ]; array[ hole ] = x;
入队操作的时间复杂度是O （N），出队操作的时间复杂度是O（1）。

入队操作的实现保持不变，将新入队的元素放在 队列尾。但出队时，在整个队列中查找优先级最 高的元素，让它出队。
入队操作的时间复杂度是O （1），出队操作的时间复杂度是O（N）。
第六章 优先级队列




基本的优先级队列 基于树形结构的优先级队列——二叉堆 D堆 归并优先级队列 STL中的优先级队列 排队系统的模拟
自然界的完全二叉树
二叉堆

堆是一棵完全二叉树，且满足下述关系之一

ki ≤ k2i 且 ki ≤ k2i+1 (i=1,2,… , n/2 ) 或者： ki ≥ k2i且 ki ≥ k2i+1 (i=1,2,… , n/2 )
其中，下标是树按层次遍历的次序

满足前一条件的称为最小化堆。例如:
}
enQueue的时间效率

最坏情况是对数的 O(logN) 平均情况，过滤会提前结束。有资料表明， 平均是2.6次比较，因此元素平均上移1.6层。
DeQueue 操作


当最小元素被删除时，在根上出现了一个 空结点。堆的大小比以前小1，堆的结构性 告诉我们，最后一个结点应该删掉。 如果最后一项可以放在此空结点中，就把 它放进去。然而，这通常是不可能的。 我们必须玩与插入操作相同的游戏：把某 些项放 入空结点，然后移动空结点。仅有 的区别在于： 对DeQueue操作，空结点是 往下移动。
二叉堆的特性


结构性：符合完全二叉树的结构 有序性：满足父节点小于子节点（最小化 堆）或父节点大于子节点（最大化堆） 以下的讨论都以最小化堆为例
二叉堆的存储

可以采用顺序存储 二叉堆的有序性可以很容易地通过下标来反映
2
0
1 2
2 3
3 4
4 5
5 7
6
7
8
9
10 23 29 60
3
4
2
向下过滤过程

找到空结点的一个较小的子结点，如果该 儿子的值小于我们要放入的项，则把该儿 子放入空结点，把空结点往下推一层，重 复这个动作，直到该项能被放入
删除最小元素
Ah! That’s simple -we only have to delete the root node ... move 18 up to the root [1] 10 18 12 And re-arrange The node which must be removed to keep a rest tree so that [2] 12 [3] 15 18 the 20 of the 12 find thecomplete smaller child of tree. 18 binary it’s still a min heap.
数据结构 Data Structure
第六章 优先级队列
第六章 优先级队列




基本的优先级队列 二叉堆 D堆 归并优先级队列 STL中的优先级队列 排队系统的模拟
基本的优先级队列

结点之间的关系是由结点的优先级决定的， 而不是由入队的先后次序决定。优先级高 的先出队，优先级低的后出队。这样的队 列称为优先级队列。
};
enQueue（x）


enQueue操作是在堆中插入一个新元素 堆的插入是在具有最大序号的元素之后插入 新的元素或结点，否则将违反堆的结构性。 如果新元素放入后，没有违反堆的有序性， 那么操作结束。否则，让该节点向父节点移 动，直到满足有序性或到达根节点。 新节点的向上移动称为向上过滤(percolate up)
[customers in a line, colliding particles] [reducing round off error] [Huffman codes] [Dijkstra's algorithm, Prim's algorithm] [sum of powers] [A* search] [maintain largest M values in a sequence] [load balancing, interrupt handling] [bin packing, scheduling] [Bayesian spam filter]
//向下过滤
public: priorityQueue( int capacity = 100 ) //创建一个空优先级队列 { array = new Type[capacity]; maxSize = capacity; currentSize = 0;} priorityQueue( const Type data[], int size ); //从一组给定
的数据创建一个优先级队列
~priorityQueue() { delete [] array; } bool isEmpty( ) const { return currentSize == 0; } void enQueue( const Type & x ); Type deQueue( ); Type getHead( ) { return array[1]; }
Priority queue

Collections. Insert and delete items. Which item to delete? Stack. Remove the item most recently added. Queue. Remove the item least recently added. Randomized queue. Remove a random item. Priority queue. Remove the largest (or smallest) item.

优先级队列类的定义
template <class Type> class priorityQueue {private: int currentSize; //队列中元素个数 Type *array; //数组的起始地址 int maxSize; //数组的规模 void doubleSpace( ); void buildHeap( ); void percolateDown( int hole );
在如下的堆中插入元素的过程：
[1] 10 9
[2] 12 [3] 20 17 10 9
15
[4]
Biblioteka Baidu
18
20 21 17
The only possible position for a new node since a heap must be a complete binary tree.
[5] [6] 20 20 < > 21 17 10 < 17
Case 1 : new_item = 21 Case 2 : new_item = 17
Case 3 : new_item = 9
20
>
9
10
>
9
enQueue过程
template <class Type> void priorityQueue<Type>::enQueue( const Type & x ) { if( currentSize == maxSize - 1 ) doubleSpace();
<
18
15 18 [4]
18 [5]
15
<
18
T (N) = O ( log N )
deQueue()
template <class Type> Type priorityQueue<Type>::deQueue() { Type minItem; minItem = array[ 1 ]; array[ 1 ] = array[ currentSize-- ]; //将最后一个元
Challenge. Find the largest M files in N items Constraint. Not enough memory to store N items
优先级队列的简单实现

利用现有的队列结构。有两种方法可以处理优先级 入队时，按照优先级在队列中寻找合适的位置， 将新入队的元素插入在此位置。出队操作的实现 保持不变。

序列{ 2,3,4,5,7,10,23,29,60 } 是最小化堆 序列{ 12,7,8,4,6,5,3,1} 是最大化堆

满足后一条件的称为最大化堆。例如:

The largest key
12
The smallest key
2
7 4 6 5
8 3 5
3 7 10
4 23
1
29
60
最大化堆
最小化堆
7 G
15
H
I
J
【定理】If a complete binary tree with n nodes is represented sequentially, then for any node with index i, 1 i n, we have:
i 2 if i 1 (1) index of parent(i ) None if i 1 if 2i n 2i (2) index of left _ child(i) None if 2i n 2i 1 if 2i 1 n (3) index of right _ child(i ) None if 2i 1 n
3 5 7 10 23
4
5
7
10
23
29
60
29
60
基于二叉堆的优先级队列

如果数值越小，优先级越高，则可以用一 个最小化堆存储优先级队列 在最小化堆中，最小元素是根元素，而根 结点永远存放在数组的下标为1的元素中。
获取队头元素的操作就是返回下标为1的数组元 素值 出队操作就是删除下标为1的数组元素中的值 入队操作就是在数组的末尾添加一个元素，但 添加后要调整元素的位置，以保持堆的有序性
素挪到根节点
percolateDown( 1 ); //向下过滤 return minItem;
}
向下过滤
template <class Type> void priorityQueue<Type>::percolateDown( int hole ) { int child; Type tmp = array[ hole ]; for( ; hole * 2 <= currentSize; hole = child ) //每次循环下移一层 { child = hole * 2; //child指向左儿子 if( child != currentSize && array[ child + 1 ] < array[ child ] ) child++; //如果右儿子存在且小于左儿子，将child指向右儿子 if( array[ child ] < tmp ) array[ hole ] = array[ child ]; //空结点
完全二叉树
定义：A binary tree with n nodes and height h is complete iff its nodes correspond to the nodes numbered from 1 to n in the perfect binary tree of height h. A complete binary tree of height h has between 2h-1 and 2h 1 nodes.