本文详细介绍了二叉树的概念，包括其定义、特点、基本形态如空二叉树、单结点、左斜树、右斜树、满二叉树和完全二叉树。此外，还探讨了二叉树的特殊类型和性质，以及前序、中序、后序和层序遍历等操作。文章最后提到了二叉树的存储结构，包括顺序存储和链式存储，并讨论了哈夫曼树及其构建过程。
二叉树的定义
二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
特点：
⑴ 每个结点最多有两棵子树；
⑵ 二叉树是有序的，其次序不能任意颠倒。
注意：二叉树和树是两种树结构。
二叉树的基本形态：
1.空二叉树
2.只有一个根结点
3.根结点只有右子树
4.根结点只有左子树
5.根结点同时有左右子树
特殊的二叉树
斜树
1 .所有结点都只有左子树的二叉树称为左斜树；
2 .所有结点都只有右子树的二叉树称为右斜树；
3.左斜树和右斜树统称为斜树。
斜树的特点：
1. 在斜树中，每一层只有一个结点；
2.斜树的结点个数与其深度相同。
满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
满二叉树的特点：
1.叶子只能出现在最下一层；
2.只有度为0和度为2的结点。
3.满二叉树在同样深度的二叉树中结点个数最多
4.满二叉树在同样深度的二叉树中叶子结点个数最多
完全二叉树
对一棵具有n个结点的二叉树按层序编号，如果编号为i（1≤i≤n）的结点与同样深度的满二叉树中编号为i的结点在二叉树中的位置完全相同。
在满二叉树中，从最后一个结点开始，连续去掉任意个结点，即是一棵完全二叉树。
完全二叉树的特点：
1. 叶子结点只能出现在最下两层，且最下层的叶子结点都集中在二叉树的左部；
2. 完全二叉树中如果有度为1的结点，只可能有一个，且该结点只有左孩子。
3. 深度为k的完全二叉树在k-1层上一定是满二叉树。
二叉树的基本性质
1.二叉树的第i层上最多有2^(i-1)个结点（i≥1）。
2.一棵深度为k的二叉树中，最多有2^k-1个结点，最少有k个结点。
3.在一棵二叉树中，如果叶子结点数为n0，度为2的结点数为n2，则有: n0＝n2＋1。
4.具有n个结点的完全二叉树的深度为 [log2n] +1。
5.对一棵具有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。
二叉树的抽象数据类型定义
ADT BiTree
Data
由一个根结点和两棵互不相交的左右子树构成，
结点具有相同数据类型及层次关系
Operation
InitBiTree
前置条件：无
输入：无
功能：初始化一棵二叉树
输出：无
后置条件：构造一个空的二叉树
DestroyBiTree
前置条件：二叉树已存在
输入：无
功能：销毁一棵二叉树
输出：无
后置条件：释放二叉树占用的存储空间
InsertL
前置条件：二叉树已存在
输入：数据值x，指针parent
功能：将数据域为x的结点插入到二叉树中，作为结点parent的左孩子。如果结点parent原来有左孩子，则将结点parent原来的左孩子作为结点x的左孩子
输出：无
后置条件：如果插入成功，得到一个新的二叉树
DeleteL
前置条件：二叉树已存在
输入：指针parent
功能：在二叉树中删除结点parent的左子树
输出：无
后置条件：如果删除成功，得到一个新的二叉树
Search
前置条件：二叉树已存在
输入：数据值x
功能：在二叉树中查找数据元素x
输出：指向该元素结点的指针
后置条件：二叉树不变
PreOrder
前置条件：二叉树已存在
输入：无
功能：前序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
InOrder
前置条件：二叉树已存在
输入：无
功能：中序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
PostOrder
前置条件：二叉树已存在
输入：无
功能：后序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
LeverOrder
前置条件：二叉树已存在
输入：无
功能：层序遍历二叉树
输出：二叉树中结点的一个线性排列
后置条件：二叉树不变
endADT
二叉树的遍历操作
二叉树的遍历是指从根结点出发，按照某种次序访问二叉树中的所有结点，使得每个结点被访问一次且仅被访问一次。
分为前序遍历、中序遍历、后序遍历、层序遍历
前序（根）遍历
若二叉树为空，则空操作返回；否则：
①访问根结点；
②前序遍历根结点的左子树；
③前序遍历根结点的右子树。
中序（根）遍历
若二叉树为空，则空操作返回；否则：
①中序遍历根结点的左子树；
②访问根结点；
③中序遍历根结点的右子树。
后序（根）遍历
若二叉树为空，则空操作返回；否则：
①后序遍历根结点的左子树；
②后序遍历根结点的右子树。
③访问根结点；
层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问。
顺序存储结构：
二叉树的顺序存储结构就是用一维数组存储二叉树中的结点，并且结点的存储位置（下标）应能体现结点之间的逻辑关系——父子关系。
完全二叉树和满二叉树中结点的序号可以唯一地反映出结点之间的逻辑关系 。
void Preorder(int root, char data[]){
if(data[root]!='\0'){
cout<<data[root] ;
Preorder(2*root,data);
Preorder(2*root+1,data);
}
return;
}
void InOrder(int root, char data[]){
if(data[root]!='\0'){
InOrder(2*root,data);
cout<<data[root] ;
InOrder(2*root+1,data);
}
return;
}
void PostOrder(int root, char data[]){
if(data[root]!='\0'){
PostOrder(2*root,data);
PostOrder(2*root+1,data);
cout<<data[root] ;
}
return;
}
void create(char preorder[],char inorder[],int start_p, int end_p,int start_i,int end_i, char data[],int root){
if(start_p>end_p)
return ;
else{
int k;
for(int i=start_i;i<=end_i;i++){
if(inorder[i]==preorder[start_p]){
k=i;
break;
}
}
data[root]=preorder[start_p];
create(preorder,inorder,start_p+1,start_p+k-start_i,start_i,k-1,data, 2*root);
create(preorder,inorder,start_p+k-start_i+1,end_p,k+1,end_i,data,2*root+1);
}
return ;
}
int main(){
char * data;
int total=1;
char preorder[100],inorder[100];
cin>>preorder>>inorder;
int length=0;
while(preorder[length]!='\0')
length++;
data=new char[pow(2,length+1)];
memset(data,'\0',pow(2,length+1));
create(preorder,inorder,0,length-1,0,length-1,data,1);
order(1,data);
return 0;
}
深度为k的右斜树，k个结点需分配2k－1个存储单元。
二叉树的顺序存储结构一般仅存储完全二叉树
二叉链表：
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
结点结构：
lchild data rchild
其中，data：数据域，存放该结点的数据信息；lchild：左指针域，存放指向左孩子的指针；rchild：右指针域，存放指向右孩子的指针。
template <class T>
struct BiNode
{
T data;
BiNode<T> *lchild, *rchild;
};
具有n个结点的二叉链表中，有n+1个空指针。
二叉链表存储结构的声明：
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);
};
前序遍历——递归算法
template <class T>
void BiTree::PreOrder(BiNode<T> *root)
{
if (root ==NULL) return;
else {
cout<<root->data;
PreOrder( );
PreOrder( );
}
}
前序遍历——非递归算法
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;
}
}
}
二叉树的建立
1.按扩展前序遍历序列输入结点的值
2.如果输入结点值为“#”,则建立一棵空的子树
3.否则，根结点申请空间，将输入值写入数据域中，
4.以相同方法的创建根结点的左子树
5.以相同的方法创建根结点的右子树
template <class T>
BiTree ::BiTree(){
root=creat()；
}
template <class T>
BiNode<T> * BiTree ::Creat(){
BiNode<T> *root; char ch;
cin>>ch;
if (ch=='# ') root=NULL;
else {
root=new BiNode<T>;
root->data=ch;
root->lchild=creat();
root->rchild= creat();
}
return root
}
template <class T>
BiNode<T> * BiTree ::Creat(){
BiNode<T> *root; char ch;
cin>>ch;
if (ch=='# ') root=NULL;
else {
root=new BiNode<T>;
root->data=ch;
root->lchild=creat();
root->rchild= creat();
}
return 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); //递归建立右子树
}
}
中序遍历——递归算法
template <class T>
void BiTree::InOrder (BiNode<T> *root)
{
if (root==NULL) return;
else {
InOrder(root->lchild);
cout<<root->data;
InOrder(root->rchild);
}
}
非递归中序遍历二叉树
思想：
遇到一个结点，就把它推入栈中，并去遍历它的左子树
遍历完左子树后，从栈顶托出这个结点并访问之，然后按照它的右链接指示的地址再去遍历该结点的右子树。
template <class T>
void BiTree::InOrderwithoutD (BiNode<T> *root)
{
stack< BiNode<T> * > aStack;
while(!aStack.empty()||root) {
while(root){
aStack.push(root);
root=root->lchild;
}
if(!aStack.empty()){
root=aStack.top();
aStack.pop();
cout<<root->data;
root=root->rchild;
}
}
}
后序遍历——递归算法
template <class T>
void BiTree::PostOrder(BiNode<T> *root)
{
if (root==NULL) return;
else {
PostOrder(root->lchild);
PostOrder(root->rchild);
cout<<root->data;
}
}
非递归后序遍历二叉树
思想:
遇到一个结点，把它推入栈中，遍历它的左子树
左子树遍历结束后，还不能马上访问处于栈顶的该结点，而是要再按照它的右链接结构指示的地址去遍历该结点的右子树
遍历遍右子树后才能从栈顶托出该结点并访问之
#include <stack>
Using namespace std;
template<class T>
void BiTree<T>::PostOrderWithoutRecusion(BiTreeNode<T>* root){
StackElement<T> element;
stack<StackElement<T > > aStack;//栈申明
BiTreeNode<T>* pointer;
if(root==NULL)
return;//空树即返回
else pointer=root;
while(true){
while(pointer!=NULL){//进入左子树
element.pointer=pointer;
element.tag=Left; //沿左子树方向向下周游
aStack.push(element);
pointer=pointer->lchild;
}
element=aStack.pop();
pointer=element.pointer;
while(element.tag==Right){
cout<<pointer->data;
if(aStack.empty()) return;
else{
element=aStack.pop();
pointer=element.pointer;
}//end else
} //endwhile
element.tag=Right;
aStack.push(element);
pointer=pointer->rchild();
}//end while
}
小结
都是沿着左分支访问，直到左分支为空时，再依次对栈中节点的右分支进行处理。（遵循从左至右的遍历原则，体现深度优先搜索的思想）
前序遍历：每个节点只进栈一次，在进栈前访问节点
中序遍历：每个节点进栈一次，在出栈时访问节点
后序遍历：每个节点进栈两次，在第二次出栈时访问节点
二叉树 层次遍历
#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);
}
三叉链表
在二叉链表的基础上增加了一个指向双亲的指针域。
结点结构
lchild data parent rchild
其中：data、lchild和rchild三个域的含义同二叉链表的结点结构；
parent域为指向该结点的双亲结点的指针。
结点数据类型声明：
template<class T>
struct Node
{
T data;
Node<T> * lchild, *rchild,*parent;
};
template <class T>
BiNode<T> * BiTree<T>::Creat(BiNode<T> * &root ,BiNode<T> *parent){
T ch;
cout<<"请输入创建一棵二叉树的结点数据"<<endl;
cin>>ch;
if (ch=="#") root = NULL;
else{
root = new BiNode<T>; //生成一个结点
root->data=ch;
root->parent=parent;
Creat(root->lchild,root ); //递归建立左子树
Creat(root->rchild,root); //递归建立右子树
}
return root;
}
template<class T>
BiTree<T>::BiTree( int i)
{
number=0;
Creat(root,NULL);
}
树和二叉树的对应关系：
树：兄弟关系=》二叉树：双亲和右孩子
树：双亲和长子=》二叉树：双亲和左孩子
树转换成二叉树：
1.兄弟加线.
2.保留双亲与第一孩子连线,删去与其他孩子的连线.
3.顺时针转动,使之层次分明.
森林转换为二叉树
⑴ 将森林中的每棵树转换成二叉树；
⑵ 从第二棵二叉树开始，
依次把后一棵二叉树的根结点作为前一棵二叉树根结点的右孩子，
当所有二叉树连起来后，此时所得到的二叉树就是由森林转换得到的二叉树。
二叉树转换为树或森林
⑴ 加线——若某结点x是其双亲y的左孩子，则把结点x的右孩子、右孩子的右孩子、……，都与结点y用线连起来；
⑵ 去线——删去原二叉树中所有的双亲结点与右孩子结点的连线；
⑶ 层次调整——整理由⑴、⑵两步所得到的树或森林，使之层次分明。
最优二叉树-哈夫曼树及哈夫曼编码
叶子结点的权值：对叶子结点赋予的一个有意义的数值量。
二叉树的带权路径长度：设二叉树具有n个带权值的叶子结点，从根结点到各个叶子结点的路径长度与相应叶子结点权值的乘积之和。
哈夫曼树：给定一组具有确定权值的叶子结点，带权路径长度最小的二叉树。
哈夫曼树的特点：
1. 权值越大的叶子结点越靠近根结点，而权值越小的叶子结点越远离根结点。
2. 只有度为0（叶子结点）和度为2（分支结点）的结点，不存在度为1的结点.
哈夫曼算法基本思想：
⑴ 初始化：由给定的n个权值{w1，w2，…，wn}构造n棵只有一个根结点的二叉树，从而得到一个二叉树集合F＝{T1，T2，…，Tn}；
⑵ 选取与合并：在F中选取根结点的权值最小的两棵二叉树分别作为左、右子树构造一棵新的二叉树，这棵新二叉树的根结点的权值为其左、右子树根结点的权值之和；
⑶ 删除与加入：在F中删除作为左、右子树的两棵二叉树，并将新建立的二叉树加入到F中；
⑷ 重复⑵、⑶两步，当集合F中只剩下一棵二叉树时，这棵二叉树便是哈夫曼树。
1. 设置一个数组huffTree[2n-1]保存哈夫曼树中各点的信息，数组元素的结点结构 。
void HuffmanTree(element huffTree[ ], int w[ ], int n ) {
for (i=0; i<2*n-1; i++) {
huffTree [i].parent= -1;
huffTree [i].lchild= -1;
huffTree [i].rchild= -1;
}
for (i=0; i<n; i++)
huffTree [i].weight=w[i];
for (k=n; k<2*n-1; k++) {
Select(huffTree, &i1, &i2);
huffTree[k].weight=huffTree[i1].weight+huffTree[i2].weight;
huffTree[i1].parent=k;
huffTree[i2].parent=k;
huffTree[k].lchild=i1;
huffTree[k].rchild=i2;
}
}
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
