树
介绍
-
n个节点的有效集，它可为空树或非空树；
-
树是一种递归的结构。
-
对于非空树：
-
有且仅有一个称为根的节点。
-
除根节点以外其余节点可分为m个互不相交 的有限集，且这些有限集本身也是一棵树，称为根的子树。
-
-
分等级的分类方案都可用树表示。
基本术语
二叉树
介绍
- 由n个节点所构成的集合，它或为空树，或为非空树。
- 对于非空树：
- 有且仅有一个根节点。
- 除根节点外的其余节点分为两个互不相交的子集T1（T的左子树）、T2（T的右子树），且T1、T2本身也是二叉树。
- 与树的区别：
- 每个节点至多有两个子树（不存在度大于2的节点）。
- 子树有左右之分，次序不能颠倒。
性质
- 在二叉树的第i层上至多有 2 ^ (i - 1) 个节点，i >= 1。
- 深度为k的二叉树至多有 2 ^ k - 1 个节点，k >= 1。
- 对任何一颗二叉树T，如果其终端节点数 为n0，度为2的节点数 为n2，则 n0 = n2 + 1。
- 具有n个节点的完全二叉树的深度为**（不大于log 2 n的最大整数）+ 1**。
- 如果对一颗有n个节点的完全二叉树的节点按层序编号（由第一层到最后一层，从左到右），则对于任意一个节点i（1 <= i <= n），有以下结论：
- 如果 i = 1，则节点i是根节点，无双亲；如果 i > 1，则其双亲是节点**（不大于i/2的最大整数）**。
- 如果2i > n，则节点 i 无左孩子 （节点i为叶节点）；否则节点i的左孩子为 2i。
- 如果2i + 1 > n，则节点 i 无右孩子 ；否则节点i的右孩子为 2i + 1。
特殊形态的二叉树
-
满二叉树：
- 深度为k且含有2 ^ k - 1 个节点的二叉树。
- 每一层上的节点数都是最大节点数 ，即每一层i的节点数都具有最大值 2 ^ (i - 1) 。
-
完全二叉树：
- 深度为k、有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中编号1~n的节点位置一一对应。
- 叶子节点只可能在层次最大的两层出现。
- 对任一节点，若其右分支 下的子孙的最大层次为l ，则左分支下 的子孙最大层次必为l或l+1。
存储结构
-
顺序存储（浪费空间，不常用）
c#define MAXTSIZE 100 typedef TElemType SqBiTree[MAXTSIZE]; SqBiTree bt;//创造了一个二叉树对象，数据在数组的排列要严格按照由第一层到最后一层，从左到右的规则来写入 /* 若遇到不存在这个节点，则用'0'代替 如上图（c）应该写入为 1 2 3 4 5 0 0 0 0 6 7 第一个0和第二个0为节点3不存在的节点，但是由于规则，必须把它表示出来 第三个0和第四个0也是这样 因为到6、7后面就没了，所以也就不用再加0了 */ -
链式存储（常用）
含有n个节点的二叉链表中有 n+1 个空链域
- 左空链域的条件：处于序列最左端，且原来左指针就是空的。
- 右空链域的条件：处于序列最右端，且原来右指针就是空的。
ctypedef struct BiTNode { TElemType data;//节点数据域 struct BiTNode *lchild, *rchild;//左右孩子指针 }BiTNode, *BiTree;
遍历
算法
- 递归
c
//中序遍历二叉树的递归算法，改变语句顺序即可实现先序和后序
void InOrderTraverse(BiTree T)
{
if(T)//若二叉树非空
{
InOrderTraverse(T -> lchild);//访问遍历左子树
cout << T->data;//访问根
InOrderTraverse(T -> rchild);//访问遍历右子树
}
}- 非递归
c
/*
中序遍历二叉树的非递归算法
1. 初始化一个空栈S，指针p指向根节点
2. 申请一个节点空间q，用来存放栈顶弹出的元素
3. 当p非空或者栈S非空时，循环以下操作：
如果p非空，则p进栈，p指向改节点的左孩子
如果p为空，则弹出栈顶元素并访问根节点，将p指向该节点的右孩子
*/
void InOrderTraverse(BiTree T)
{
InitStack(S);
p = T;
q = new BiTNode;
while(p || !StackEmpty(S))
{
if(p)//如果一直有就一直遍历左子树，把节点压到栈内，直到最后
{
Push(S, p);
p = p -> lchild;
}
else//如果到底了就输出，然后遍历右子树
{
Pop(S, q);
cout << q -> data;
p = q -> rchild;
}
}
}注：根据一个先序 序列和中序序列可以唯一确定一个二叉树，根据一个后序序列和中序序列可以唯一确定一个二叉树，方法看B站
层次遍历
c
/*
层次遍历：从上到下，从左到右遍历二叉树
算法：
1. 创建一个空队列，先保存根节点
2. 进入循环，令指针p（指示当前的节点）对于队列第一个，将第一个出队
3. 输出数据
4. 如果有左右节点，保存到队列，便于后续遍历
5. 队列不为空时重复234
*/
void LevelTraverse(BiTree T)
{
queue<BiTree>tq;
tq.push(T);//从第一个根节点开始，从上到下
while (!tq.empty())
{
BiTree q = tq.front();
tq.pop();
cout << q->data;//访问该节点，并且把它的孩子保存进队列，顺序也刚刚好是从左到右
if (q->lchild != NULL) tq.push(q->lchild);
if (q->rchild != NULL) tq.push(q->rchild);
}
}应用
创建二叉树的存储结构
c
/*
为简化问题，设节点元素为字符。假设按先序遍历的顺序建立二叉链表，T为指向二叉树根节点的指针，对于一个特定的字符序列，依次读入字符，从根节点开始，递归创建二叉树。
算法步骤：
1. 查找字符序列，读入字符ch
2. 如果ch是一个'#'（相当于前面顺序存储结构的'0'，代表次节点是空的），则代表二叉树为空；否则执行以下操作：
。申请一个节点空间T
。将ch赋给T->data
。递归创建T的左子树
。递归创建T的右子树
*/
void CreateBiTree(BiTree &T)
{
cin >> ch;
if(ch == '#') T = NULL;//递归结束，建空树
else
{
T = new BiTNode;//生成根节点
T -> data = ch;//写入数据
CreateBiTree(T -> lchild);//递归创建左子树
CreateBiTree(T -> rchild);//递归创建右子树
}
}复制二叉树
c
/*
按先序遍历去复制。
算法步骤：
二叉树若为空，递归结束；否则执行以下操作：
。申请一个新节点空间，复制根节点
。递归复制T的左子树
。递归复制T的右子树
*/
void Copy(BiTree T, BiTree &NewT)
{
if(T = NULL)
{
NewT = NULL;//空树，递归结束
return;
}
else
{
NewT = new BiTNode;//创建新节点
NewT -> data = T -> data;//复制根节点
Copy(T -> lchild, NewT -> lchild);//递归复制左节点
Copy(T -> rchild, NewT -> rchild);//递归复制右节点
}
}计算二叉树的深度
c
/*
按先序遍历去计算。
算法步骤：
二叉树若为空，递归结束；否则执行以下操作：
。递归计算左子树的深度m
。递归计算右子树的深度n
。如果m > n，二叉树的深度为m + 1，否则为n + 1（从第二层开始，所以最后要加上根节点）
*/
int Depth(BiTree T)
{
if(T == NULL)return 0;//如果树是空的，直接返回0
else
{
m = Depth(T->lchild);//递归计算左子树深度m
n = Depth(T->rchild);//递归计算右子树n
if(m > n) return(m + 1);
else return n + 1;
}
}统计二叉树中节点的个数
c
/*
按先序遍历去计算。
算法步骤：
二叉树若为空，递归结束；否则节点个数等于 左子树节点个数 + 右子树节点个数 + 1
*/
int NodeCount(BiTree T)
{
if(T = NULL)return 0;
else NodeCount(T->lchild) + NodeCount(T->rchild) + 1;
}线索二叉树
介绍
上面的遍历实际上就是把非线性结构变成线性结构，使之能够找到前驱和后继，但是不能找到任何序列的前驱和后继。故而引进线索二叉树来保存这些东西。
规定如下：
-若节点有左子树，则其lchild域指示其左孩子，否则令lchild域指示其前驱。
-若节点有右子树，则其rchild域指示其右孩子，否则令rchild域指示其前驱。
为了避免混淆，直接在节点添加两个标志域，如下图：
二叉树的二叉线索存储表示
以这种节点结构构成的二叉链表作为二叉树的存储结构，叫做线索链表。
其中指向前驱和后继的指针叫做线索。
加上线索的二叉树叫做线索二叉树。
对二叉树以某种次序遍历使其变为线索二叉树的过程叫做线索化。
c
typedef struct BiThrNode
{
TElemType data;
struct BiThrNode *lchild, *rchild;
int LTag, RTga;
}BiThNode, *BiThrTree;构造
已经有一个二叉树了，只不过将他线索化，构造出线索二叉树，需要在遍历中依次更改节点的空指针域。
以节点p为根的子树中序线索化（图a）
c
/*
按中序遍历线索化，定义一个pre始终指向刚刚访问过的节点，p始终指向当前访问节点。
算法步骤：
。如果p非空，左子树递归线索化
。如果p的左孩子为空，则给p加上左线索，将其LTag置为1，让p的左孩子指针指向pre（前驱）；否则把p的LTag置0
。如果p的右孩子为空，则给p加上右线索，将其RTag置为1，让p的右孩子指针指向pre（后继）；否则把p的RTag置0
。将pre指向刚刚访问过的节点p，即 pre = p
。右子树递归线索化
*/
BiThrTree pre = NULL;//全局变量，初始化为空，方便其右孩子从最左节点进入
void InThreading(BiThrTree p)
{
if(p) //树p不为空
{
InThreading(p->lchild);//因为中序遍历为左根右，故而当前节点进来应该先处理左边，故将左边线索化
if(!p->lchild)//如果当前节点左孩子为空
{
p->LTag = 1;
p->lchild = pre;//当前节点的左孩子指针域指示前驱，线性化时的前一个点
}
else p->LTag = 0;//当前点的左孩子不为空，则当前点的左孩子标志则置0
if(!pre->rchild)//前驱的右孩子为空，设置前驱节点的后继，线性化的后一个点
{
pre->RTag = 1;
pre->rchild = p;//前驱的右孩子为空，则接当前节点的地址
}
else pre->RTag = 0;//前驱的右孩子不为空，则前驱的右孩子标志则置0
pre = p;//继续遍历
InThreading(p->rchild);//往右遍历
}
}带头节点的二叉树中序线索化（图b）
为了方便操作，添加一个头节点，让第一种图中的最左节点左孩子指向头节点，最右节点的右孩子指向头节点的右孩子，头节点左孩子指向根节点，右孩子指向最右节点的右孩子（最后一个节点），以下的代码就是在上面加上这些定义即可。
c
BiThrTree pre = NULL;//全局变量，初始化为空，方便其右孩子从最左节点进入
void InOrderThreading(BiThrTree &Thrt, BiThrTree T)
{//Thrt指向头节点
//构造一个头节点
Thrt = new BiThrNode;
Thrt->LTag = 0;//因为左孩子要指向根节点，故标志初始化为0
Thrt->RTag = 1;//右孩子要指向最右节点
Thrt->rchild = Thrt;//初始化时指向它自己
if(!T) Thrt->lchild = Thrt;
else
{
//头节点的左孩子指向根节点
Thrt->lchild = T;
pre = Thrt;//将全局变量初始化为头节点，在下面的函数内递归时就会发生最左节点的左孩子指向头节点
InThreading(T);//返回的pre为最右节点
pre->rchild = Thrt;//令最右节点指向头节点
pre->RTag = 1;//最右没有内容，故置1
Thrt->Rchild = pre;//令头节点右孩子指向最右节点
}
}遍历
中序
c
/*
按中序遍历线索化
算法步骤：
1. 指针p指向根节点
2. p为非空或遍历未结束，循环执行以下操作：
。沿左孩子往下，到达最左下节点，它是中序的第一个节点
。访问该节点进行输出
。沿右线索反复查找当前节点的后继节点并访问后继节点，直到右线索为0或者遍历结束
。转向p的右子树
*/
void InOrderTraverse_Thr(BiThrTree T)
{
p = T->lchild;//头节点的左孩子为根节点
while(p != T)//不为空树
{
while(p->LTag == 0) p = p->lchild;//遍历到最左边的第一个节点，下面输出
cout << p->data;
while(p->RTag == 1 && p->rchild != T)//若标志为0则指已经返回到了上一个中间节点 / 遍历结束（最后一个节点的右孩子指向头节点）
{
p = p->rchild;//刚刚进来还是上一个节点，要先换到下一个
cout << p->data;//输出
}
p = p->rchild;//继续遍历中间节点的右子树
}
}树和森林
存储结构
-
双亲表示法：节点内有两个域，一个是数据域（data），一个是指示其父母亲（parent）
-
孩子表示法
-
孩子兄弟表示法
c//节点结构有第一个孩子节点，数据，下一个孩子节点 typedef struct CSNode { ElemType data; struct CSNode *firstchild, *nextsibling; }CSNode, *CSTree;
注：剩下的可以看课本
哈夫曼树
介绍
又称最优树，是一类带权路径长度最短的树，在实际生活有着广泛的应用。
构造
-
构造过程
- 给定n个权值{w1,w2,...,wn}，构造n棵只有根节点的二叉树，这n棵二叉树构成森林F。
- 在森林F中选取两棵根节点的权值最小的树（构造的新树也算，若权值最小是新树之外的两颗，那就重新再组有课树）作为左右子树构造新的二叉树，且其根节点权值为左右孩子权值和。
- 在森林F中删去这两棵树，同时加入新的树。
- 重复2、3直到F只含一棵树为止。
-
构造算法
c#include<iostream> using namespace std; /* 树节点结构：权值weight+父母parent+左孩子lchild+右孩子rchild 存储在大小为2n-1(n个节点构成的哈夫曼树有2n-1个节点)的数组内，但是为了方便，0不使用，从1开始，所以数组大小要定义为2n，通过下标去调用 */ typedef struct { int weight;//权值 int parent, lchild, rchild;//对应下标 }HTNode, * HuffmanTree; //HT数组中存放的哈夫曼树，end表示HT数组中存放结点的最终位置，s1和s2传递的是HT数组中权重值最小的两个结点在数组中的位置 void Select(HuffmanTree HT, int end, int& s1, int& s2) { int min1, min2; //遍历数组初始下标为 1 int i = 1; //找到还没构建树的结点 while (HT[i].parent != 0 && i <= end) { i++; } min1 = HT[i].weight; s1 = i; i++; while (HT[i].parent != 0 && i <= end) { i++; } //对找到的两个结点比较大小，min2为大的，min1为小的 if (HT[i].weight < min1) { min2 = min1; s2 = s1; min1 = HT[i].weight; s1 = i; } else { min2 = HT[i].weight; s2 = i; } //两个结点和后续的所有未构建成树的结点做比较 for (int j = i + 1; j <= end; j++) { //如果有父结点，直接跳过，进行下一个 if (HT[j].parent != 0) { continue; } //如果比最小的还小，将min2=min1，min1赋值新的结点的下标 if (HT[j].weight < min1) { min2 = min1; min1 = HT[j].weight; s2 = s1; s1 = j; } //如果介于两者之间，min2赋值为新的结点的位置下标 else if (HT[j].weight >= min1 && HT[j].weight < min2) { min2 = HT[j].weight; s2 = j; } } } /* 算法步骤 1.初始化 ·申请大小2n的动态数组，从1开始循环到2n-1，把所有节点的父母、孩子都设为0 ·循环n次（1-n），输入n个叶子节点的权值 2.创建树 ·循环n-1次（n+1~2n）的选择、删除与合并来创建哈夫曼树 ·选择：从当前森林选出双亲为0且权值最小的节点的下标s1和s2 ·删除：把s1和s2的父母改为非0，即当前的下标 ·合并：把s1和s2的权值相加，成为当前节点的权值，同时记录左右孩子下标，即s1和s2 */ void CreateHuffmanTree(HuffmanTree& HT, int n) { if (n <= 1) return;//检测输入是否正确 /*--------------------------------------------初始化--------------------------------------------------------*/ int m = 2 * n - 1;//n个叶子节点构建的树有2n-1个节点 HT = new HTNode[m + 1];//从1开始，故加一 for (int i = 1; i <= m; i++) {//全部置0 HT[i].parent = 0; HT[i].lchild = 0; HT[i].rchild = 0; } for (int i = 1; i < n; i++) {//输入权值 cin >> HT[i].weight; } /*-------------------------------------------构造哈夫曼树----------------------------------------------------*/ for (int i = n + 1; i <= m; i++) { int s1, s2; Select(HT, i - 1, s1, s2);//选择函数 HT[i].lchild = s1;//当前节点左孩子设置为s1 HT[i].rchild = s2;//当前节点右孩子设置为s2 HT[s1].parent = HT[s2].parent = i;//s1、s2父母设置为当前节点下标 HT[i].weight = HT[s1].weight + HT[s2].weight;//当前节点权值为s1和s2总和 } }
编码
进行数据压缩时，为了使压缩后的数据文件尽可能短，可采用不定长编码。为了正确编码，用哈夫曼树来实现。
关于编码，有两个概念：
- 前缀编码：在一个编码方案里，任一个编码都不是其他任何编码的前缀（最左子串），则为前缀编码。（不懂百度一下）
- 哈夫曼编码：约定左支为0，右支为1，则根节点到每个叶子节点路径上的0、1序列就是对应编码。以下是哈夫曼编码的性质
- 哈夫曼编码是前缀编码
- 哈夫曼编码是最优前缀编码
c
/*
哈夫曼编码表存储结构
因为每个编码不等长，所以定义一个二维字符数组来存储
为了方便，数组下标从1开始使用，故为n+1行
因为事先不能确定编码长度，为了不浪费内存空间，定义一个一维字符数组（长度为n，编码一定不会大于n）来存储后再移入编码表里。值得注意的是，因为哈夫曼编码是从根到叶，而记入cd时是从叶到根，所以需要我们记入cd时要反过来记入
*/
typedef char **HuffmanCode;//动态分配数组存储哈夫曼编码表
/*
算法步骤
1.分配存储n个字符编码的编码表空间HC，长度为n+1
2.分配临时编码存储数组cd，长度为n，cd[n-1]置为'\0'
3.逐个字符求编码，循环n次，执行以下操作
·设置start用于记录编码在cd中存放的位置，初始化指向最后
·设置变量c用于记录从叶子向上回溯到根节点所经过的节点下标，c初始化为等待编码字符的下标i
·设置变量f用于记录i双亲节点的下标
4.从叶子向上回溯到根节点，当没有回溯到根节点，循环执行以下操作
·回溯一次start向前指一个位置，即--start
·若节点c是f的左孩子，生成0；否则生成1，保存在cd中
·继续回溯，改变c和f的值
5.分配HC空间，记入编码
*/
void CreateHuffmanCode(HuffmanTree HT, HuffmanCode& HC, int n)
{
HC = new char* [n + 1];
char* cd = new char[n];
cd[n - 1] = '\0';
for (int i = 1; i <= n; i++)
{
//前期准备
int start = n - 1;
int c = i;
int f = HT[i].parent;
//开始编码
while (f != 0)//没有到根节点，哈夫曼树只有根节点是无双亲的
{
--start;
if (HT[f].lchild = c)cd[start] = '0';
else cd[start] = '1';
c = f;
f = HT[f].parent;
}
//记入HC
HC[i] = new char[n - start];
strcpy(HC[i], &cd[start]);//记得include<string>
}
delete cd;//释放临时空间
}