目录
开启“树”之旅
是不是很像一棵倒挂的树？也就是说它是根朝上， 而叶子朝下的。不像？哈哈，来看看下面的图你就会觉得像啦。
你可能会间： 树和图有什么区别？这个称之为树的东西和无向图差不多嘛。不要着急，继续往下看。树其实就是不包含回路的连通无向阳。你可能还是无法理解这其中的差异， 下面举个例子。 
二叉树
二义树是一种特殊的树。二叉树的特点是每个结点最多有两个儿子， 左边的叫做左儿子，右边的叫做右儿子， 或者说每个结点最多有两棵于树。更加严格的递归定义是： 二叉树要么为空， 要么由根结点、左子树和右子树组成， 而左子树和石子树分别是一棵二叉树。下面这棵树就是一棵二叉树。
二叉树的使用范阶最广，一棵多叉树也可以转化为二叉树， 因此我们将着重讲解二叉树。
二叉树中还有两种特殊的二叉树， 叫做满二义树和完全二叉树。如果二叉树中每个内部结点都有两个儿子， 这样的二叉树叫做满二叉树。或者说满二义树所有的叶结点都有同样的深度。比如下面这棵二叉树， 是不是感觉很“ 丰满＂。满二叉树的严格的定义是一棵深度为h且有2^h-1个结点的二叉树。
其实完全二叉树类似下面这个形状。
说到这里我们马上就要领略到完全二叉树的魅力了。先想一想： 一棵完全二叉树如何存储呢？其实完全二叉树中父亲和儿子之间有着神奇的规律，我们只需用一个一维数组就可以存储完全二叉树。首先将完全二叉树进行从上到下， 从左到右编号。
堆--优先队列
假如有14 个数， 分别是99、5 、36、7、22、17 、46、12 、2 、19 、25 、28 、1 和92, 请找出这14个数中最小的数， 请间怎么办呢？最简单的方法就是将这14个数从头到尾依次扫一遍， 用一个循环就可以解决。这种方法的时间复杂度是0(14)， 也就是O(N) 。
for (i = 1; i <= 14; i++) {
if (a [i] <min) {
min=a [i];
}
}
现在我们需要删除其中最小的数， 并增加一个新数23, 再次求这14 个数中最小的一个数。请间该怎么办呢？只能重新扫描所有的数， 才能找到新的最小的数， 这个时间复杂度也是O(N)。假如现在有14 次这样的操作（删除最小的数后再添加一个新数）， 那么整个时间复杂度就是0(14^2)即O(N2)。那有没有更好的方法呢？堆这个特殊的结构恰好能够很好地解决这个问题。
首先我们把这14 个数按照最小堆的要求（就是所有父结点都比子结点要小）放入一棵完全二叉树， 就像下面这棵树一样。
很显然最小的数就在堆顶， 假设存储这个堆的数组叫做h的话， 最小数就是h[1] 。接下来， 我们将堆顶部的数删除。将新增加的数23放到堆顶。显然加了新数后已经不符合最小堆的特性， 我们需要将新增加的数调整到合适的位置。那如何调整呢？
void siftdown(int i) //传入一个需要向下调整的节点编号i，这里传入1，即从堆的顶点开始向下调整
{
int t, flag = 0;//flag用来交际是否需要继续向下调整
//当i节点有儿子(其实是至少有左儿子的情况下)并且有需要继续调整的时候，循环就执行
while(i * 2 <= n && flag == 0) {
//首先判断他和左儿子的关系，并用t记录值较小的节点编号
if (h[i] > h[i*2]) {
t = i * 2;
} else {
t = i;
}
//如果他有右儿子，再对有儿子进行讨论
if (i * 2 + 1 <= n) {
//如果右儿子的值更小，更新较小的节点编号
if (h[t] > h[i*2+1]) {
t = i * 2 + 1;
}
}
//如果发现最小的节点编号不是自己，说明子节点中有比父节点更小的
if (t != i) {
swap(t, i);
i = t;//更新i为刚才与他交换的儿子节点的编号，便于继续向下调整
} else {
flag = 1;//否则说明当前父节点小于子节点，不用调整了
}
}
}
void siftup(int i)//传入一个需要向上调整的节点编号i
{
int flag = 0;
if (i == 1) {
return;//如果是堆顶，返回
}
//不在堆顶，并且当前节点i的值比父节点小的时候就继续向上调整
while(i != 1 && falg == 0) {
//判断是否比父节点的小
if (h[i] < h[i/2]) {
swap(i, i/2);
} else {
flag = 1;//整理表示已经不用调整，当前节点的值比父节点大
}
i = i/2;//这句话很重要，更新编号i为他父节点的编号，从而便于下一次继续向上调整
}
}说了半天， 我们忽略了一个很重要的问题！就是如何建立这个堆。可以从空的堆开始，然后依次往堆中插入每一个元素， 直到所有数都被插入（转移到堆中）为止。因为插入第i个元索所用的时间是O(log i) ，所以插入所有元索的整体时间复杂度是O(MogN), 代码如下。
n = 0;
for (i = 1; i <= m; i++) {
n++;
h[n] = a[i];//或写成scanf("%d", &h[n]);
siftup();
}
小结一下这个创建堆的算法。把n个元素建立一个堆， 首先我可以将这n个结点以自顶向下、从左到右的方式从1到n编码。这样就可以把这n个结点转换成为一棵完全二叉树。紧接着从最后一个非叶结点（结点编号为n/2)开始到根结点（结点编号为1)， 逐个扫描所有的结点， 根据需要将当前结点向下调整， 直到以当前结点为根结点的子树符合堆的特件。虽然讲起来很复杂， 但是实现起来却很简单， 只有两行代码如下：
for (i = n/2; i >= 1; i--) {
siftdown(i);
}用这种方法来建立一个堆的时间复杂度是O(N), 堆还有一个作用就是堆排序，与快速排序一样，堆排序的时间复杂度也是O(NlogN).堆排序的实现很简单， 比如我们现在要进行从小到大排序，可以先建立最小堆， 然后每次删除顶部元素并将顶部元素输出或者放入一个新的数组中，直到堆为空为止。最终输出的或者存放在新数组中的数就已经是排序好的了。
//删除最大的元素
int deletemax() {
int t;
t = h[1];//用一个临时变量记录堆顶点的值
h[1] = h[n];//将堆的最后一个点赋值到堆顶
n--;//堆的元素减少1
siftdown(1);//向下调整
return t;//返回之前记录的堆的顶点的最大值
}建堆以及堆排序的完整代码如下：
#include <stdio.h>
int h[101]; // 用来存放堆的数组
int n; // 用来存储堆中元素的个数，也就是堆的大小
// 交换函数，用来交换堆中的两个元素的值
void swap(int x, int y) {
int t;
t = h[x];
h[x] = h[y];
h[y] = t;
}
// 向下调整函数
void siftdown(int i) { // 传入一个需要向下调整的结点编号i，这里传入1，即从堆的顶点开始向下调整
int t, flag = 0; // flag用来标记是否需要继续向下调整
// 当i结点有儿子（其实是至少有左儿子）并且有要继续调整的时候循环就执行
while (i * 2 <= n && flag == 0) {
// 首先判断它和左儿子的关系，并用t记录值较小的结点编号
if (h[i] > h[i * 2])
t = i * 2;
else
t = i;
// 如果它有右儿子，再对右儿子进行讨论
if (i * 2 + 1 <= n) {
// 如果右儿子的值更小，更新较小的结点编号
if (h[t] > h[i * 2 + 1])
t = i * 2 + 1;
}
// 如果发现最小的结点编号不是自己，说明子结点中有比父结点更小的
if (t != i)
swap(t, i); // 交换它们，注意swap函数要自己来写
else
flag = 1; // 否则说明当前的父结点已经比两个子结点都要小了，不需要再进行调整了
}
}
// 建立堆的函数
void create() {
int i;
// 从最后一个非叶结点到第1个结点依次进行向上调整
for (i = n / 2; i >= 1; i--) {
siftdown(i);
}
}
// 删除最大的元素
int deleteMax() {
int t;
t = h[1]; // 用一个临时变量记录堆顶点的值
h[1] = h[n]; // 将堆的最后一个点赋值到堆顶
n--; // 堆的元素减少1
siftdown(1); // 向下调整
return t; // 返回之前记录的堆的顶点的最大值
}
int main() {
int i, num;
// 读入要排序的数字的个数
scanf("%d", &num);
for (i = 1; i <= num; i++)
scanf("%d", &h[i]);
n = num;
// 建堆
create();
// 删除顶部元素，连续删除n次，其实也就是从大到小把数输出来
for (i = 1; i <= num; i++)
printf("%d ", deleteMax());
getchar();
getchar();
return 0;
}当然堆排序还有一种更好的方法。从小到大排序的时候不建立最小堆而建立最大堆， 最大堆建立好后， 最大的元素在h[1]，因为我们的需求是从小到大排序， 希望最大的放在最后。因此我们将h[1]和h[n]交换， 此时h[n]就是数组中的最大的元素。请注意， 交换后还需将h[1]向下调整以保持堆的特性。OK, 现在最大的元素已经归位， 需要将堆的大小减1即n--,然后再将h[1]和h[n]交换， 并将h[l]向下调整。如此反复， 直到堆的大小变成1为止。此时数组h中的数就已经是排序好的了。代码如下：
//堆排序
void heapsort() {
while(n > 1) {
swap(1, n);
n--;
siftdown(1);
}
}完整的堆排序的代码如下，注意使用这种方法来进行从小到大排序需要建立最大堆。
#include <stdio.h>
#define lOl 1000 // 用来存放堆的数组大小
int h[lOl]; // 用来存放堆的数组
int n; // 用来存储堆中元素的个数，也就是堆的大小
// 交换函数，用来交换堆中的两个元素的值
void swap(int x, int y) {
int t = h[x];
h[x] = h[y];
h[y] = t;
}
// 向下调整函数
void siftdown(int i) { // 传入一个需要向下调整的结点编号i，这里传入1，即从堆的顶点开始向下调整
int t, flag = 0; // flag用来标记是否需要继续向下调整
// 当i结点有儿子（其实是至少有左儿子）并且有需要继续调整的时候循环就执行
while (i * 2 <= n && flag == 0) {
// 首先判断它和左儿子的关系，并用t记录较大的结点编号
if (h[i] < h[i * 2])
t = i * 2;
else
t = i;
// 如果它有右儿子，再对右儿子进行讨论
if (i * 2 + 1 <= n) {
// 如果右儿子的值更大，更新较小的结点编号
if (h[t] < h[i * 2 + 1])
t = i * 2 + 1;
}
// 如果发现最大的结点编号不是自己，说明子结点中有比父结点更大的
if (t != i) {
swap(t, i); // 交换它们，注意swap函数需要自己来写
i = t; // 更新i为刚才与它交换的儿子结点的编号，便于接下来继续向下调整
} else {
flag = 1; // 否则说明当前的父结点已经比两个子结点都要大了，不需要再进行调整了
}
}
}
// 建立堆的函数
void create() {
int i;
// 从最后一个非叶结点到第1个结点依次进行向上调整
for (i = n / 2; i >= 1; i--) {
siftdown(i);
}
}
// 堆排序
void heapsort() {
while (n > 1) {
swap(1, n);
n--;
siftdown(1);
}
}
int main() {
int i, num;
// 读入n个数
scanf("%d", &num);
for (i = 1; i <= num; i++) {
scanf("%d", &h[i]);
}
n = num;
// 建堆
create();
// 堆排序
heapsort();
// 输出
for (i = 1; i <= num; i++) {
printf("%d ", h[i]);
}
getchar();
getchar();
return 0;
} 最后还是要总结一下。像这样支持插入元素和寻找最大（小）值元素的数据结构称为优先队列．如果使用普通队列来实现这两个功能，那么寻找最大元素需要枚举整个队列，这样的时间复杂度比较高。如果是已排序好的数组， 那么插入一个元素则需要移动很多元素，时间复杂度依旧很高。而堆就是一种优先队列的实现， 可以很好地解决这两种操作。
另外Dijkstra 算法中每次找离源点最近的一个顶点也可以用堆来优化， 使算法的时间复杂度降到O((M+N)logN)。堆还经常被用来求一个数列中第K 大的数， 只需要建立一个大小为K的最小堆， 堆顶就是第K大的数。（我举个例子， 假设有10个数， 要求第3大的数。第一步选取任意3个数， 比如说是前3个， 将这3个数建成最小堆， 然后从第4个数开始， 与堆顶的数比较， 如果比堆顶的数要小， 那么这个数就不要， 如果比堆顶的数要大， 则舍弃当前堆顶而将这个数做为新的堆顶， 并再去维护堆， 用同样的方法去处理第5~10个数）
并查集
上一节用了很长的篇幅讲解了树在优先队列中的应用一堆的实现。那么树还有哪些神奇的用法呢？咱们从一个故事说起一解密犯罪团伙。
要想解决这个问题， 首先我们假设这10个强盗相互是不认识的， 他们各自为政， 每个人都是首领， 他们只听从自己的。之后我们将通过警方提供的线索，一步步地来“ 合并同伙"。
#include <stdio.h>
int f[1000] = {0}, n, m, k, sum = 0;
// 这里是初始化，非常地重要，数组里面存的是自己数组下标的编号就好了。
void init() {
int i;
for (i = 1; i <= n; i++) {
f[i] = i;
}
}
// 这是找爹的递归函数，不停地去找爹，直到找到祖宗为止，其实就是去找犯罪团伙的最高领导人，“擒贼先擒王”原则。
int getf(int v) {
if (f[v] == v) {
return v;
} else {
// 这里是路径压缩，每次在函数返回的时候，顺带把路上遇到的v的“BOSS”改为最后找到的祖宗编号，
// 也就是犯罪团伙的最高领导人编号。这样可以提高今后找到犯罪团伙的最高领导人（其实就是树的祖先）的速度。
f[v] = getf(f[v]);
return f[v];
}
}
// 这里是合并两子集合的函数
void merge(int v, int u) {
int t1, t2;
t1 = getf(v);
t2 = getf(u);
if (t1 != t2) { // 判断两个结点是否在同一个集合中，即是否为问一个祖先。
f[t2] = t1;
// “靠左”原则，左边变成右边的BOSS。即把右边的集合，作为左边集合的子集合。
// 经过路径压缩以后，将f[u]的根的值也赋值为v的祖先f[t1]。
}
}
// 请从此处开始阅读程序，从主函数开始阅读程序是一个好习惯。
int main() {
int i, x, y;
scanf("%d %d", &n, &m);
// 初始化是必须的
init();
for (i = 1; i <= m; i++) {
// 开始合并犯罪团伙
scanf("%d %d", &x, &y);
merge(x, y);
}
// 最后扫描有多少个独立的犯罪团伙
for (i = 1; i <= n; i++) {
if (f[i] == i) {
sum++;
}
}
getchar(); // 清除输入缓冲区
getchar(); // 清除输入缓冲区
printf("%d\n", sum); // 输出独立团伙数量
return 0;
}并查集也称为不相交集数据结构。此算法的发展经历了十多年， 研究它的人也很多， 其中Robert E. Tarjan做出了很大的贡献。在此之前John E. Hopcroft和Jeffrey D. Ullman也进行了大量的分析。你是不是又感觉Robert E. Tarjan和John E. Hopcroft很熟悉？没错， 就是发明了深度优先搜索的两个人一1986年的图灵奖得主。你看牛人们从来都不闲着的。他们到处交流， 寻找合作伙伴，一起改变世界。
483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
