【挑战程序设计竞赛（第二版）】2.4【数据结构：队列&堆、二叉树、二叉搜索树、并查集】

优先队列&堆

优先队列：可以插入一个数字；可以取出最小的数字并且删除
堆：父节点的值一定不小于子结点，所有节点从上到下、从左到右按序排列
时间复杂度O(logn)

以下程序是堆的操作代码实现，不需要用指针构建二叉树，只用一维数组按照节点编号存储堆即可。
i 结点的两个子结点编号为 2i+1和2i+2。

/*
堆：
初始化，就是将所有点存放到数组中【完全二叉树】 
删除堆顶元素 
添加元素 
*/ 
#include<iostream>
#include<cstdio>
using namespace std;
#define MAX_N 10000
int heap[MAX_N], sz = 0; // 结点数标号 

// 插入 
void push(int x){
	int i = sz++;
	while(i > 0) {
		int p = (i - 1) / 2; // 父节点的编号 
		if(heap[p] <= x) break;	// 小根堆，不需要调整
		else {
			heap[i] = heap[p];	// 否则就把父节点往下移
			i = p;	// 继续向上找 
		} 
	}
	heap[i] = x;
}

// 删除
int pop() {
	// 堆顶元素 
	int rec = heap[0];
	// 最后一个放到堆顶
	int x = heap[sz] ;
	// 自上向下开始交换
	int i = 0; 
	while(i * 2 + 1 < sz) {
		// 比较儿子的值
		int a = i * 2 + 1, b = i * 2 + 2;
		if(b < sz && heap[b] < heap[a]) a = b; // 把较小的儿子放在a这里 
		
		if(heap[a] >= x) break;
		
		heap[i] = heap[a];
		i = a;
	}
	 heap[i] = x;
	 return rec;
}

int main(){
	int a[] = {6,5,8,4,7,9,1,3,2};
	for (int i = 0; i < sizeof(a)/sizeof(int); i++){
		push(a[i]);
	}
	for (int i = 0; i < sizeof(a)/sizeof(int); i++){
		cout<<heap[i] <<endl;
	}	// 1  2  4  3  7  9  8  6  5
	cout<<pop()<<endl;
	return 0;
}

**优先队列：**在C++的库函数中，用priority_queue已经实现了堆，所以就不需要自己写上面的具体操作了，直接调用即可。

/*
优先队列priority_queue ,默认是从大到小排序的 
*/ 
#include<queue> 
#include<cstdio>
using namespace std;

int main(){
	priority_queue<int> pque;// 声明
	
	pque.push(5); 
	pque.push(3);
	pque.push(7);
	
	// 弹出priority_queue中的元素 
	while (!pque.empty()) {
		printf("%d\n",pque.top());
		pque.pop();
	}
	
	return 0; 
} 

要想加油次数最少，要在保证卡车足以行驶的前提下，每次在量最多的据点加油，所以用到据点油量的排序。
Runtime Error

/*
优先队列priority_queue ,默认是从大到小排序的 
Expedition(POJ 2431) 
问题描述：
	卡车行驶总距离 L = 25
	初始油量 P = 10单位
	中途有加油站 N = 4 个
	从起点到每一个加油站的距离为 Ai = {10, 14, 20, 21}
	每一个加油站可以加的油量是 Bi = {10, 5, 2, 4}
	油量和距离是一比一消耗关系，油箱是可以无限量的
目标： 
	最少的加油次数，如果不能正常到达终点输出-1
input:
4 25 10
10 14 20 21
10 5 2 4 
*/ 
#include<queue> 
#include<iostream>
using namespace std;

const int MAX_N = 100;
int N,L,P;
int A[MAX_N+1],B[MAX_N];

void solve(){
//	A[N] = L;	
//	B[N] = 0;
	// cnt: 加油次数 pos:现在的位置，tank:油箱中油量 
	int cnt = 0,pos = 0,tank = P;
	// 用来暂时存放每一个据点的油 
	priority_queue<int> pque;
	for(int i = 0; i < N; i++){
		// 还要走的距离
		int d = A[i] - pos;
		// 油不够了 
		while( tank - d < 0) {
			if(pque.empty()) {
				cout<<"-1"<<endl;
			}
			tank += pque.top(); // 把据点暂存的最多的油加入油箱 
			pque.pop();	// 据点的油就没了 
			cnt++; // 加油一次 
		}
		pos = A[i]; 
		tank -= d;
		pque.push(B[i]);	// 现在油箱够着呢，就把经过的据点的油暂存 
	}
	cout<<cnt;
}

int main(){
	// 依次输入据点数，总距离，初始油量，据点坐标，每一句点的油量 
	cin>>N>>L>>P;
	for(int i = 0; i < N; i++){
		cin>>A[i];
	}
	for(int i = 0; i < N; i++){
		cin>>B[i];
	}
	solve();
	return 0; 
} 

原来朴素的算法时间复杂度是O(N²)，使用优先序列的为O(N log N)

/*
Fence Repair(POJ 3253)
input:
5
5 1 2 4 3 
output:
33 
*/
#include<iostream> 
#include<queue>
#include<algorithm> 
using namespace std;
typedef long long ll;

const int MAX_N = 100;
int n;
int L[MAX_N];

// 直到计算到木板为1块时为止 
void solve(){
	ll ans = 0;
	// 声明一个从小到大的优先队列 
	//	priority_queue<Type, Container, Functional>
	//	greater<int> less<int>
	priority_queue <int,vector<int>,greater<int> > que;
	for (int i =0;i<n;i++) {
		que.push(L[i]);
	}
	while(que.size() > 1) {
		int s,p;
		s = que.top();
		que.pop();
		p = que.top();
		que.pop();
		ans += s+p;
		que.push(s+p);
	}
	cout<<ans;
}
int main(){
	cin>>n;
	for (int i = 0; i < n; i++) {
		cin>>L[i];
	}
	solve();
	return 0;
}

---

二叉搜索树

特点：所有节点的左儿子结点比他小，右儿子节点比他大
操作：

• 方便插入
• 方便删除
• 方便查找
  删除的情况处理：（A结点为待删除结点）
• A结点没有左儿子，就把右儿子提上去
• A结点的左儿子没有右儿子，就把左儿子提上去
• 左右儿子都有，左儿子也有自己的右儿子，将左儿子最大的子孙提上去
  时间复杂度：与树的高度成正比，所以都是O(log N)

以下四张图分别是二叉搜索树及其查找、插入、删除的图示。

以下是二叉搜索树的代码实现：

/*
插入、删除、查找
平衡二叉树
遍历打印 
*/
#include<iostream>
#include<queue>
using namespace std;

struct node {
	int val;
	node *lch,*rch;
}; 

node *insert(node *p, int x) { 
	if (p == NULL){
		node *q = new node;
		q->val = x;
		q->lch = q->rch = NULL;
		return q;
	} else {
		if (x < p->val) p->lch = insert(p->lch,x);
		else p->rch = insert(p->lch,x);
		return p;
	}
}

bool find(node *p, int x){
	if (p == NULL) return false;
	if (x == p->val) return true;
	else if (x < p->val) return find(p->lch,x);
	else return find(p->rch,x);	
}
/*
1. 没有左儿子 ，提右儿子 
2. 有左儿子 没有左儿子的右孙子，提左儿子
3. 否则，提左儿子的子孙最大者[既有左儿子，又有右儿子，左儿子还有右儿子]
*/
node *remove(node *p,int x){
	if (p == NULL) return NULL;
	else if (x < p->val) p->lch = remove(p->lch, x);
	else if (x > p->val) p->rch = remove(p->rch, x);
	else if (p->lch == NULL){
		node *q = p->rch;
		delete p;
		return q;
	} else if( p->lch->rch == NULL){
		node *q = p->lch;
		q->rch = p->rch; 
		delete p;	
		return q;
	} else {
		node *q;
		for(q = p->lch; q->rch->rch = NULL; q = q->rch) ;
		node *r = q->rch;
		q->rch = r->lch;
		r->lch = p->lch;
		r->rch = p->rch;
		delete p;
		return r;
	}  
	return p;
}

/*
打印遍历过程
*/
void pre_order_traverse(node* T){
	if(T){
		cout<< T->val<<"   ";
		pre_order_traverse(T->lch);
		pre_order_traverse(T->rch);
	}
}

int main(){
	node *root = NULL;
	root->val = 1;
	cout<<find(root,1);
	return 0;
}

在C++中，STL中的set和map容器就可以实现简单可用的二叉搜索树。STL基本用法
multiset 和 multimap 可以存放重复的键值。

---

并查集

1. 是什么？
   管理元素分组情况的数据结构，可以进行合并操作，不可以分割。
   • 查询两元素是否属于同一组【同根则同组】
   • 合并两元素所在组
2. 结构：可以用树实现
   • 初始化：n个结点，没有边
   • 合并：仅仅是树形结构，将森林合并成树
   • 查询：如果两节点的根是同一个，就是同一组的
3. Attention!!!
   注意树瘦高高带来的复杂度高的问题：
   • 记录树的高度rank;
   • 合并时，rank不同的数，小的放到大的下边，图一
   • 路径压缩，图二【最好的结果就是每一个结点直接连着自己的根节点，如下面全部简化的样子】
     

4. 复杂度

5. 代码实现
并查集包含一个数组记录前导点，包含两个函数：找根节点和合并。

int par[MAX_N];	// 定义每一个结点的前一个结点序号
	int rank[MAX_N];	// 高度 
	// 初始化
	void init (int n){
		for (int i = 0; i < n; i++){
			par[i] = i;	// 初始化，每一个结点的爸爸都是自己
			rank[i] = 0; // 每一个结点所在的树高都是0
		}
	}
	
	// 找爸爸（root）,顺道路径压缩
	int find(int root) {
		int son = root;
		while ( par[root] != root) { // 只要爸爸不是自己，他就不是根节点
			root = par[root];
		}
		while(son != root) { // 路径压缩
			int tmp = par[son];
			par[son] = root; // 将所有人的爸爸改成root
			son = par[son];
		}
	}
	// 判断x,y是不是一个爸爸
	bool same (int x, int y) {
		return find(x) == find(y);
	}
	// 合并
	void unite (int x, int y) {
		if(same(x,y)) return;
		if(rank[x] < rank[y]){
			par[x] = y;
		} else {
			par[y] = x;
			if(rank[x] == rank[y]) rank[x]++;
		}
	}

6. 应用（POJ 1182 食物链）
   food chain