树
1.树的定义
树：n（n≥0）个结点的有限集合。
当n＝0时，称为空树；
任意一棵非空树满足以下条件：
⑴ 有且仅有一个特定的称为根的结点；
⑵ 当n＞1时，除根结点之外的其余结点被分成m（m>0）个互不相交的有限集合T1,T2,… ,Tm，其中每个集合又是一棵树，并称为这个根结点的子树。
2.树的基本术语
结点的度：结点所拥有的子树的个数。
树的度：树中各结点度的最大值。
叶子结点：度为0的结点，也称为终端结点。
分支结点：度不为0的结点，也称为非终端结点。
孩子、双亲：树中某结点子树的根结点称为这个结点的孩子结点，这个结点称为它孩子结点的双亲结点；
兄弟：具有同一个双亲的孩子结点互称为兄弟。
路径：如果树的结点序列n1, n2, …, nk有如下关系：结点ni是ni+1的双亲（1<=i<k），则把n1, n2, …, nk称为一条由n1至nk的路径；路径上经过的边的个数称为路径长度。
祖先、子孙：在树中，如果有一条路径从结点x到结点y，那么x就称为y的祖先，而y称为x的子孙。
结点所在层数：根结点的层数为1；对其余任何结点，若某结点在第k层，则其孩子结点在第k+1层。
树的深度：树中所有结点的最大层数，也称高度。
层序编号：将树中结点按照从上层到下层、同层从左到右的次序依次给他们编以从1开始的连续自然数。
有序树、无序树：如果一棵树中结点的各子树从左到右是有次序的，称这棵树为有序树；反之，称为无序树。
森林：m (m≥0)棵互不相交的树的集合。
同构：对两棵树，若通过对结点适当地重命名，就可以使这两棵树完全相等（结点对应相等，结点对应关系也相等），则称这两棵树同构。
3.树的抽象数据类型定义
DestroyTree
前置条件：树已存在
输入：无
功能：销毁一棵树
输出：无
后置条件：释放该树占用的存储空间
Root
前置条件：树已存在
输入：无
功能：求树的根结点
输出：树的根结点的信息
后置条件：树保持不变
Parent
前置条件：树已存在
输入：结点x
功能：求结点x的双亲
输出：结点x的双亲的信息
后置条件：树保持不变
Depth
前置条件：树已存在
输入：无
功能：求树的深度
输出：树的深度
后置条件：树保持不变
PreOrder
前置条件：树已存在
输入：无
功能：前序遍历树
输出：树的前序遍历序列
后置条件：树保持不变
PostOrder
前置条件：树已存在
输入：无
功能：后序遍历树
输出：树的后序遍历序列
后置条件：树保持不变
endADT
5.数的遍历方法
树的遍历：从根结点出发，按照某种次序访问树中所有结点，使得每个结点被访问一次且仅被访问一次。
6.前序遍历
树的前序遍历操作定义为：
若树为空，不进行遍历；否则
⑴ 访问根结点；
⑵ 按照从左到右的顺序前序遍历根结点的每一棵子树。
7.后序遍历
树的后序遍历操作定义为：
若树为空，则遍历结束；否则
⑴ 按照从左到右的顺序后序遍历根结点的每一棵子树；
⑵ 访问根结点。
8.层序遍历
树的层序遍历操作定义为：
从树的第一层（即根结点）开始，自上而下逐层遍历，在同一层中，按从左到右的顺序对结点逐个访问。
9.双亲表示法
基本思想：
用一维数组来存储树的各个结点（一般按层序存储），
数组中的一个元素对应树中的一个结点，
每个结点记录两类信息：结点的数据信息以及该结点的双亲在数组中的下标。
data：存储树中结点的数据信息
parent：存储该结点的双亲在数组中的下标
template <class T>
struct PNode{
T data; //数据域
int parent; //指针域，双亲在数组中的下标
} ;
10.孩子表示法-多重链表表示法（节点中的指针域表示孩子）
链表中的每个结点包括一个数据域和多个指针域，每个指针域指向该结点的一个孩子结点。
方案一：指针域的个数等于树的度
其中：data：数据域，存放该结点的数据信息；
child1~childd：指针域，指向该结点的孩子。
方案二： 指针域的个数等于该结点的度
其中：data：数据域，存放该结点的数据信息；
degree：度域，存放该结点的度；
child1~childd：指针域，指向该结点的孩子。
11.孩子表示法-孩子链表表示法（每个节点创建一个单链表）
特点：将每个结点的所有孩子放在一起，构成线性表。
基本思想：
把每个结点的孩子排列起来，看成是一个线性表，且以单链表存储，则n个结点共有 n 个孩子链表。
这 n 个单链表共有 n 个头指针，这 n 个头指针又组成了一个线性表。
为了便于进行查找采用顺序存储存储每个链表的头指针。
最后，将存放 n 个头指针的数组和存放n个结点的数组结合起来，构成孩子链表的表头数组。
孩子链表表示法
孩子结点
struct CTNode
{
int child;
CTNode *next;
};
表头结点
template <class T>
struct CBNode
{
T data;
CTNode *firstchild;
};
12.孩子兄弟表示法
data：数据域，存储该结点的数据信息；
firstchild：指针域，指向该结点第一个孩子；
rightsib：指针域，指向该结点的右兄弟结点。
template <class T>
struct TNode{
T data;
TNode <T> *firstchild, *rightsib;
};
13.二叉树的定义
二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
14.二叉树的特点：
⑴ 每个结点最多有两棵子树；
⑵ 二叉树是有序的，其次序不能任意颠倒
14.斜树
所有结点都只有左子树的二叉树称为左斜树；
所有结点都只有右子树的二叉树称为右斜树；
左斜树和右斜树统称为斜树。
15.斜树的特点：
在斜树中，每一层只有一个结点；
斜树的结点个数与其深度相同。
16.满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
17.满二叉树的特点：
叶子只能出现在最下一层；
只有度为0和度为2的结点。
满二叉树在同样深度的二叉树中结点个数最多
满二叉树在同样深度的二叉树中叶子结点个数最多
18.完全二叉树
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同。
在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树。
19.完全二叉树的特点
叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；
完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。
深度为k的完全二叉树在k-1层上一定是满二叉树。
20.二叉树的基本性质
二叉树的第i层上最多有2i-1个结点（i≥1）。
一棵深度为k的二叉树中，最多有2k-1个结点，最少有k个结点。
在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。
21.完全二叉树的基本性质
具有n个结点的完全二叉树的深度为 log2n +1。
对一棵具有n个结点的完全二叉树中从1开始按层序编号，则对于任意的序号为i（1≤i≤n）的结点（简称为结点i），有：
（1）如果i＞1，
则结点i的双亲结点的序号为 i/2；如果i＝1，
则结点i是根结点，无双亲结点。
(2)如果2i≤n，
则结点i的左孩子的序号为2i；
如果2i＞n，则结点i无左孩子。
(3)如果2i＋1≤n，
则结点i的右孩子的序号为2i＋1；如果2i＋1＞n，则结点 i无右孩子。
二叉树的逻辑结构：
对一棵具有n个结点的完全二叉树中从1开始按层序编号，则
结点i的双亲结点为 i/2；
结点i的左孩子为2i；
结点i的右孩子为2i＋1。
22.二叉树的遍历操作
二叉树的遍历是指从根结点出发，按照某种次序访问二叉树中的所有结点，使得每个结点被访问一次且仅被访问一次。
23.层序遍历：按二叉树的层序编号的次序访问各结点。
24.前序（根）遍历
若二叉树为空，则空操作返回；否则：
①访问根结点；
②前序遍历根结点的左子树；
③前序遍历根结点的右子树。
25.中序（根）遍历
若二叉树为空，则空操作返回；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树。
26.后序（根）遍历
若二叉树为空，则空操作返回；否则：
①后序遍历根结点的左子树；
②后序遍历根结点的右子树。
③访问根结点；
27.顺序存储结构
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。
28.二叉链表
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
其中，data：数据域，存放该结点的数据信息；
lchild：左指针域，存放指向左孩子的指针；
rchild：右指针域，存放指向右孩子的指针。
template <class T>
struct BiNode
{
T data;
BiNode<T> *lchild, *rchild;
};
29.二叉链表存储结构的类声明
template <class T>
class BiTree
{
public:
BiTree();
~BiTree( );
void PreOrder(){PreOrder(root);}
void InOrder() {InOrder(root);}
void PostOrder() {PostOrder(root);}
void LevelOrder(){LeverOrder(root)};
private:
BiNode<T> *root;
BiNode<T> * Creat( );
void Release(BiNode<T> *root);
void PreOrder(BiNode<T> *root);
void InOrder(BiNode<T> *root);
void PostOrder(BiNode<T> *root);
void LevelOrder(BiNode<T> *root);
};
30.前序遍历——递归算法
template <class T>
void BiTree::PreOrder(BiNode<T> *root) {
if (root ==NULL) return;
else {
cout<<root->data;
PreOrder(root->lchild);
PreOrder(root->rchild);
}
}
31.前序遍历——非递归算法
二叉树前序遍历的非递归算法的关键：
在前序遍历过某结点的整个左子树后，如何找到该结点的右子树的根指针。
解决办法：在访问完该结点后，将该结点的指针保存在栈中，以便以后能通过它找到该结点的右子树。
栈是实现递归的最常用的结构
思想：
遇到一个结点，就访问该结点，并把此结点推入栈中，然后遍历它的左子树；
遍历完它的左子树后，从栈顶托出这个结点，并按照它的右链接指示的地址再去遍历该结点的右子树结构。
前序遍历——非递归算法（伪代码）
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空
2.1 当root不空时循环
2.1.1 输出root->data;
2.1.2 将指针root的值保存到栈中；
2.1.3 继续遍历root的左子树（root=root->lchild）
2.2 如果栈s不空，则
2.2.1 将栈顶元素弹出至root（root=s.pop()）；
2.2.2 准备遍历root的右子树(root=root->rchild)；
template <class T>
void BiTree::PreOrder(BiNode<T> *root) {
SeqStack<BiNode<T> *> s;
while (root!=NULL | | !s.empty()) {
while (root!= NULL) {
cout<<root->data;
s.push（root）;
root=root->lchild;
}
if (!s.empty()) {
root=s.pop();
root=root->rchild;
}
}
}
32.二叉树的建立
遍历是二叉树各种操作的基础，可以利用遍历的思想完成二叉树的各种操作，例如建立一棵二叉树。
设二叉树中的结点均为一个字符。假设扩展二叉树的前序遍历序列由键盘输入，root为指向根结点的指针，二叉链表的建立过程是：
按扩展前序遍历序列输入结点的值
如果输入结点值为“#”,则建立一棵空的子树
否则，根结点申请空间，将输入值写入数据域中，
以相同方法的创建根结点的左子树
以相同的方法创建根结点的右子树
递归方法
template <class T>
class BiTree{
public:
BiTree();
~BiTree( );
void PreOrder(){PreOrder(root);}
void InOrder() {InOrder(root);}
void PostOrder() {PostOrder(root);}
void LevelOrder();
private:
BiNode<T> *root;
void Creat(BiNode<T> *& root);
void Release(BiNode<T> *root);
void PreOrder(BiNode<T> *root);
void InOrder(BiNode<T> *root);
void PostOrder(BiNode<T> *root);
void LevelOrder(BiNode<T> *root);
};
template <class T>
void BiTree<T>::Creat(BiNode<T> * &root )
{
T ch;
cout<<"请输入创建一棵二叉树的结点数据"<<endl;
cin>>ch;
if (ch=="#") root = NULL;
else{
root = new BiNode<T>; //生成一个结点
root->data=ch;
Creat(root->lchild ); //递归建立左子树
Creat(root->rchild); //递归建立右子树
}
}
33.中序遍历——递归算法
template <class T>
void BiTree::InOrder (BiNode<T> *root)
{
if (root==NULL) return;
else {
InOrder(root->lchild);
cout<<root->data;
InOrder(root->rchild);
}
}
34.非递归中序遍历
思想：
遇到一个结点，就把它推入栈中，并去遍历它的左子树
遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。
1.栈s初始化（空栈）；
2.循环直到root为空且栈s为空
2.1 当root不空时循环
2.1.1 将指针root的值保存到栈中；
2.1.2 继续遍历root的左子树（root=root->lchild）
2.2 如果栈s不空，则
2.2.1 将栈顶元素弹出至root（root=s.pop()）；
2.2.2 输出root->data;
2.2.3 准备遍历root的右子树(root=root->rchild)；
template <class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
{
stack< BiNode<T> * > aStack;
while(root){
aStack.push(root);
root=root->lchild;
}
if(!aStack.empty()){
root=aStack.top();
aStack.pop();
cout<<root->data;
root=root->rchild;
}
}
}
35.后序遍历——递归算法
template <class T>
void BiTree::PostOrder(BiNode<T> *root)
{
if (root==NULL) return;
else {
PostOrder(root->lchild);
PostOrder(root->rchild);
cout<<root->data;
}
}
36.非递归后序遍历二叉树
思想:
遇到一个结点，把它推入栈中，遍历它的左子树
左子树遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树
遍历遍右子树后才能从栈顶托出该结点并访问之
算法分析
定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；
无条件进行下面的工作
如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③
p=p->lchild,重复①
栈顶元素出栈P
查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤
访问当前节点P
如果栈空 ，算法结束；
否则，栈顶元素出栈，转④
修改P的标志，让P重新入栈，p=P->rchild,执行2
栈中的元素类型定义StackElement
enum Tags{Left,Right}; //特征标识定义
template <class T>
class StackElement //栈元素的定义
{
public:
BiTreeNode<T>* pointer; //指向二叉树结点的指针
Tags tag; //特征标识申明
};
37.层序遍历
1.队列Q初始化；
2. 如果二叉树非空，将根指针入队；
循环直到队列Q为空
3.1 q=队列Q的队头元素出队；
3.2 访问结点q的数据域；
3.3 若结点q存在左孩子，则将左孩子指针入队；
3.4 若结点q存在右孩子，则将右孩子指针入队；
#include <queue>
using namespace std;
template<class T>
void BiTree<T>::LevelOrder(BinaryTreeNode<T>* root){
queue<BiTreeNode<T>*> aQueue;
if(root)
aQueue.push(root);
while(!aQueue.empty())
{
root=aQueue.front(); //取队列首结点
aQueue.pop();
cout<<pointer->data;//访问当前结点
if(root->lchild) //左子树进队列
aQueue.push(root->lchild);
if(root->rchild) //右子树进队列
aQueue.push(root->rchild);
}//end while
}
二叉树的析构
template<class T>
void BiTree<T>::Release(BiNode<T>* root){
if (root != NULL){
Release(root->lchild); //释放左子树
Release(root->rchild); //释放右子树
delete root;
}
}
template<class T>
BiTree<T>::~BiTree(void)
{
Release(root);
}
38.森林转换为二叉树
⑴ 将森林中的每棵树转换成二叉树；
⑵ 从第二棵二叉树开始，
依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，
当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。
39.森林的遍历
森林有两种遍历方法：
⑴前序（根）遍历：前序遍历森林即为前序遍历森林中的每一棵树。
⑵后序（根）遍历：后序遍历森林即为后序遍历森林中的每一棵树。
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
40.哈夫曼树：给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。
41.哈夫曼树的特点：
1. 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。
2. 只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点.
42.哈夫曼算法基本思想：
⑴ 初始化：由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}；
⑵ 选取与合并：在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和；
⑶ 删除与加入：在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中；
⑷ 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树。
43.哈夫曼算法的存储结构
其中：weight：权值域，保存该结点的权值；
lchild：指针域，结点的左孩子结点在数组中的下标；
rchild：指针域，结点的右孩子结点在数组中的下标；
parent：指针域，该结点的双亲结点在数组中的下标。
1.数组huffTree初始化，所有元素结点的双亲、左
右孩子都置为-1；
2. 数组huffTree的前n个元素的权值置给定值w[n]；
3. 进行n-1次合并
3.1 在二叉树集合中选取两个权值最小的根结点，
其下标分别为i1, i2；
3.2 将二叉树i1、i2合并为一棵新的二叉树k(初值为n；依次递增)；
44.哈夫曼树应用——哈夫曼编码
编码：给每一个对象标记一个二进制位串来表示一组对象。
例：ASCII，指令系统
等长编码：表示一组对象的二进制位串的长度相等。
不等长编码：表示一组对象的二进制位串的长度不相等。
前缀编码：一组编码中任一编码都不是其它任何一个编码的前缀 。
前缀编码保证了在解码时不会有多种可能。
45.哈夫曼编码算法的实现
从叶子结点到根， 逆向求每个叶子结点对应的哈夫曼编码
根据huffman树中叶子节点的个数，构造一个字符串数组，每个数组分量是一个字符串，用于存放该节点对应的huffman编码
对每个叶子节点i(i=0; i<n; i++)，进行下面的工作：
46.线索二叉树
二叉树的遍历运算是将二叉树中结点按一定规律线性化的过程。
当以二叉链表作为存储结构时，只能找到结点的左、右孩子信息，而不能直接得到结点在遍历序列中的前驱和后继信息。
要得到这些信息可采用以下两种方法：
第一种方法是将二叉树遍历一遍，在遍历过程中便可得到结点的前驱和后继，但这种动态访问浪费时间；
第二种方法是充分利用二叉链表中的空链域， 将遍历过程中结点的前驱、 后继信息保存下来。
47.线索链表
线索：将二叉链表中的空指针域指向前驱结点和后继结点的指针被称为线索；
线索化：使二叉链表中结点的空链域存放其前驱或后继信息的过程称为线索化；
线索二叉树：加上线索的二叉树称为线索二叉树。
48.线索二叉树
二叉树的遍历方式有4种，故有4种意义下的前驱和后继，相应的有4种线索二叉树：
⑴ 前序线索二叉树
⑵ 中序线索二叉树
⑶ 后序线索二叉树
⑷ 层序线索二叉树
389
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
