二叉树的基本概念
一、二叉树的定义
二叉树是n（n≥0）个结点的有限集合，该集合或者为空集（称为空二叉树），或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树的二叉树组成。
二、二叉树的特点
⑴ 每个结点最多有两棵子树；⑵ 二叉树是有序的，其次序不能任意颠倒。
三、特殊的二叉树
一、斜树
1 .所有结点都只有左子树的二叉树称为左斜树；2 .所有结点都只有右子树的二叉树称为右斜树；3.左斜树和右斜树统称为斜树。
特点：1. 在斜树中，每一层只有一个结点；2.斜树的结点个数与其深度相同。
二、满二叉树
在一棵二叉树中，如果所有分支结点都存在左子树和右子树，并且所有叶子都在同一层上。
特点：1.叶子只能出现在下一层。2.只有度为2和度为0的节点。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个结点的完全二叉树的深度为
。
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无右孩子。
五、二叉树的遍历
一、前序遍历
若二叉树为空，则空操作返回；否则：①访问根结点；②前序遍历根结点的左子树；③前序遍历根结点的右子树。
二、中序遍历
若二叉树为空，则空操作返回；否则：①中序遍历根结点的左子树；②访问根结点；③中序遍历根结点的右子树。
三、后序遍历
若二叉树为空，则空操作返回；否则：①后序遍历根结点的左子树；②后序遍历根结点的右子树。③访问根结点；
四、层序遍历
二叉树的层次遍历是指从二叉树的第一层（即根结点）开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问。
六、二叉树的存储结构
一、顺序存储
完全二叉树和满二叉树中结点的序号可以唯一地反映出结点之间的逻辑关系 。
//前序遍历
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;
}
二、二叉链表
基本思想：令二叉树的每个结点对应一个链表结点，链表结点除了存放与二叉树结点有关的数据信息外，还要设置指示左右孩子的指针。
结点结构：
| lchild | data | rchild |
data：数据域，存放该结点的数据信息；lchild：左指针域，存放指向左孩子的指针；rchild：右指针域，存放指向右孩子的指针。
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(root->lchild);
PreOrder(root->lchild);
}
}
//中序遍历
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::PostOrder(BiNode<T> *root)
{
if (root==NULL) return;
else {
PostOrder(root->lchild);
PostOrder(root->rchild);
cout<<root->data;
}
}
template <class T>
BiTree ::BiTree(){
root=creat()；
}
//层序遍历
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>
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>
void BiTree<T>::Release(BiNode<T>* root){
if (root != NULL){
Release(root->lchild); //释放左子树
Release(root->rchild); //释放右子树
delete root;
}
}
1.前序遍历——非递归算法
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;
}
}
}
2.中序遍历——非递归算法
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(!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;
}
}
}
3.后序遍历——非递归算法
1.定义一个栈；从根节点出发开始遍历，p=root，如果，root==NULL, 不进行遍历；
2.无条件进行下面的工作
①如果指针不空，指针打上left标记，并将指针进栈，执行②;否则，执行③
②p=p->lchild,重复①
③栈顶元素出栈P
④查看P的标志，如果标志为right,进行下面的工作，否则，执行⑤
a)访问当前节点P
b)如果栈空 ，算法结束；
c)否则，栈顶元素出栈，转④
⑤修改P的标志，让P重新入栈，p=P->rchild,执行2
三、三叉链表
在二叉链表的基础上增加了一个指向双亲的指针域。
结点结构：
| 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;
}
扫一扫
479
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
