-
- 优先队列
- 堆
- 1 基于堆的算法
- 初始化
- 自底向上堆化
- 自顶向下堆化
- 插入删除一项
- 2 堆排序
- 1 基于堆的算法
- 优先队列全部代码
1 优先队列
普通的队列是一种先进先出的数据结构，元素在队列尾追加，而从队列头删除。在优先队列中，元素被赋予优先级。当访问元素时，具有最高优先级的元素最先删除。优先队列具有最高级先出 （largest-in，first-out）的行为特征。
优先队列支持两种基本操作：向优先队列中插入一个新的数据项，删除（最大）优先队列中关键字最大的数据项。 优先队列具有很好的灵活性，能支持的操作：
- 根据N个数据项构造一个优先队列
- 插入一个数据项
- 删除最大值的数据项
- 改变任意给定的数据项的优先级
- 删除任意给定的数据项
- 合并两个优先队列为一个优先队列
排序：先插入所有记录，然后逐个删除最大元素得到逆序的记录。
[注] 研究各种数据结构，我们都将铭记两个基本的权衡策略： 链表内存分配和顺序内存分配（数组）。
不同的实现对于要执行的各种操作具有不同的性能特征，不同的应用问题需要高效的不同操作集的性能。如：有序表删除快插入慢，无序表删除慢插入快。
2 堆
堆的数据结构，能够支持优先队列的基本操作。在堆中，父节点中的关键字都大于或等于其子节点中的关键字。
如果一棵树中每个节点的关键字都大于或等于所有子节点的关键字（如果存在），称树是堆有序的。
堆是一个节点的集合，表示为数组，其中关键字按堆有序的完全二叉树的形式排列。直观想，我们应该用链表表示堆有序的树，但是完全二叉树给了我们使用压缩数组表示的机会。
在位置i处的父节点，两个子节点的位置分别是 2i 和 2i+1.
2.1 基于堆的算法
如果我们对基于堆的优先队列做一点简单修改，可以侵犯堆的条件，然后通过遍历堆，在需要的时候修改堆使其满足堆的条件，我们把这个过程称为堆化或修正堆。
有两种情况需要修正堆：
（1）某个节点的优先级增加或新节点被插入到堆底，需要向上遍历堆修复
（2）某个节点的优先级降低或删除了最大项，需要向下遍历堆修复
初始化
//优先队列数据结构
struct PQ
{
Item data[maxN];
int N;
};
//初始化
PQ* PQInit()
{
PQ* pq = (PQ*)malloc(sizeof(*pq));
pq->N = 0;
return pq;
}自底向上堆化
//Insert一项时，从数组尾部插入，向上修复
void PQFixUp(PQ *pq)
{
int k = pq->N; // k节点的父节点是 k/2
while(k > 1 && less(pq->data[k/2], pq->data[k]))//共比较 lg N 次
{
exch(pq->data[k/2], pq->data[k]);
k = k/2;
}
}自顶向下堆化
如果节点关键字比它的一个或两个子节点的关键字小，那么交换该节点与较大的子节点，这种交换会影响子节点不满足堆性质，所以用同样的方法修正它。
//删除最大（顶部）节点，从上向下 fix
void PQFixDown(PQ *pq)
{
int k = 1;
int N = pq->N;
while(2*k <= N) //共比较 2*lg N 次（找更大的子节点lgN, 判断是否交换lgN）
{
int j = 2*k;
if(j < N && less(pq->data[j], pq->data[j+1]))//找较大子节点
j++;
if(!less(pq->data[k], pq->data[j])) //父节点不小于最大的子节点时，fix完成
break;
exch(pq->data[k], pq->data[j]);
k = j;
}
}插入、删除一项
//Insert an element,插入到数组尾部，然后向上fix
void PQInsert(PQ *pq, Item v)
{
pq->data[++(pq->N)] = v;
PQFixUp(pq);
}
//delete max-第一个节点；向下fix
Item PQDelMax(PQ *pq)
{
if(PQIsEmpty(pq))
{
printf("Error: pq is empty. Can‘t delete Max\n");
return -1;
}
exch(pq->data[1], pq->data[pq->N]);//交换最大的与最后一项
(pq->N)--;//剔除最后一项（最大）
PQFixDown(pq);
return pq->data[pq->N + 1];
}删除时，如果无序表对用与选择排序，有序表对应于插入排序
2.2 堆排序
void PQSort(Item a[], int l, int r)
{
PQ* pq = PQInit();
int i;
for(i = l; i <= r; i++)
PQInsert(pq, a[i]);
for(i = r; i >= l; i--)
a[i] = PQDelMax(pq);
}3 优先队列全部代码
/*======================================================
Title：基于数组的优先队列实现：k父节点，2k、2k+1为子节点
数据项存储在数组的 1~N 项中。
Functions: 插入一项，向上堆化保持有序；
删除并返回最大项，向下堆化保持有序
Author: quinn
Date: 2015/03/27
=======================================================*/
#include<stdlib.h>
#include<stdio.h>
#define maxN 100 //队列的最大容量
typedef int Item;
typedef struct PQ PQ;
#define exch(A, B) {Item t; t = A; A = B; B = t;}
#define less(A, B) (A < B)
//优先队列数据结构
struct PQ
{
Item data[maxN];
int N;
};
//初始化
PQ* PQInit()
{
PQ* pq = (PQ*)malloc(sizeof(*pq));
pq->N = 0;
return pq;
}
bool PQIsEmpty(PQ *pq)
{
return pq->N == 0;
}
//Insert一项时，从数组尾部插入，向上修复
void PQFixUp(PQ *pq)
{
int k = pq->N;
while(k > 1 && less(pq->data[k/2], pq->data[k]))//共比较 lg N 次
{
exch(pq->data[k/2], pq->data[k]);
k = k/2;
}
}
//删除最大（顶部）节点，从上向下 fix
void PQFixDown(PQ *pq)
{
int k = 1;
int N = pq->N;
while(2*k <= N) //共比较 2*lg N 次（找更大的子节点lgN, 判断是否交换lgN）
{
int j = 2*k;
if(j < N && less(pq->data[j], pq->data[j+1]))
j++;
if(!less(pq->data[k], pq->data[j])) //父节点不小于最大的子节点时，fix完成
break;
exch(pq->data[k], pq->data[j]);
k = j;
}
}
//Insert an element,插入到数组尾部，然后向上fix
void PQInsert(PQ *pq, Item v)
{
pq->data[++(pq->N)] = v;
PQFixUp(pq);
}
//delete max-第一个节点；向下fix
Item PQDelMax(PQ *pq)
{
if(PQIsEmpty(pq))
{
printf("Error: pq is empty. Can‘t delete Max\n");
return -1;
}
exch(pq->data[1], pq->data[pq->N]);
(pq->N)--;
PQFixDown(pq);
return pq->data[pq->N + 1];
}
int main()
{
PQ* pq = PQInit();
for(int i = 0; i < 10; i++)
PQInsert(pq, i);
for (int i = 0; i < 11; ++i)
{
printf("%d\n", PQDelMax(pq));
}
}