数和二叉树——二叉树的建立及应用（遍历等）（基础篇）

二叉树：二叉树是每个结点最多有两个子树的有序树。

先来介绍一下二叉树的一些基本性质吧~

二叉树的性质：

1.非空二叉树上叶子结点数等于双分支节点数加一。

性质1 二叉树第i层上的结点数目最多为2^i-1(i≥1)。
证明：用数学归纳法证明：
　    归纳基础：i=1时，有2^i-1=2⁰=1。因为第1层上只有一个根结点，所以命题成立。
    　归纳假设：假设对所有的j(1≤j<i)命题成立，即第j层上至多有2^j-1个结点，证明j=i时命题亦成立。
    　归纳步骤：根据归纳假设，第i-1层上至多有2^i-2个结点。由于二叉树的每个结点至多有两个孩子，故第i层上的结点数至多是第i-1层上的最大结点数的2倍。即j=i时，该层上至多有2×2^i-2=2^i-1个结点，故命题成立。
性质2 深度为k的二叉树至多有2^k-1个结点(k≥1)。
证明：在具有相同深度的二叉树中，仅当每一层都含有最大结点数时，其树中结点数最多。因此利用性质1可得，深度为k的二叉树的结点数至多为：
                2⁰+2¹+…+2^k-1=2^k-1

等比数列求和公式：
    故命题正确。
性质3 在任意-棵二叉树中，若终端结点的个数为n₀，度为2的结点数为n₂，则n_o=n₂+1。
证明：因为二叉树中所有结点的度数均不大于2，所以结点总数(记为n)应等于0度结点数、1度结点(记为n₁)和2度结点数之和：
                     n=n_o+n₁+n₂ (式子1)
　    另一方面，1度结点有一个孩子，2度结点有两个孩子，故二叉树中孩子结点总数是：
                      n_l+2n₂
　　树中只有根结点不是任何结点的孩子，故二叉树中的结点总数又可表示为：
                      n=n₁+2n₂+1 (式子2)
　　由式子1和式子2得到：
                      n_o=n₂+1
完全二叉树(Complete BinaryTree) 
    若一棵二叉树至多只有最下面的两层上结点的度数可以小于2，并且最下一层上的结点都集中在该层最左边的若干位置上，则此二叉树称为完全二叉树。
  特点：
  （1） 满二叉树是完全二叉树，完全二叉树不一定是满二叉树。
  （2） 在满二叉树的最下一层上，从最右边开始连续删去若干结点后得到的二叉树仍然是一棵完全二叉树。
  （3） 在完全二叉树中，若某个结点没有左孩子，则它一定没有右孩子，即该结点必是叶结点。

  性质：对完全二叉树中编号为i的结点（n为结点数），有：

（1）若i<(n/2)（下取整），则编号为i的节点为分支节点，否则为叶子节点。

（2）若n为奇数，则每个分支节点都既有左孩子结点，也有右孩子结点。

（3）若编号为i的节点有左孩子结点，则左孩子结点的编号为2i；若编号为i的节点有右孩子结点，则左孩子结点的编号为2i+1。

（4）除树根结点外，若一个节点的编号为i，则它的双亲结点编号为（i/2）（下取整）

（5）具有n个结点的完全二叉树的深度为log2n+1。
满二叉树(FullBinaryTree) 
    　一棵深度为k且有2^k-1个结点的二又树称为满二叉树。
    　满二叉树的特点：
　　（1） 每一层上的结点数都达到最大值。即对给定的高度，它是具有最多结点数的二叉树。
　　（2） 满二叉树中不存在度数为1的结点，每个分支结点均有两棵高度相同的子树，且树叶都在最下一层上。

基本性质讲完了，不够的欢迎补充~~

接下来说说二叉树的存储结构及其建立：

顺序存储：用一组地址连续的存储单元来存放二叉树的元素。（先确定好树中个元素的次序）

    确定次序：编号：层次从上到下，每层从左到右。对于编号为i的节点，若存在左孩子，则左孩子编号为2i，若存在右孩子，则编号为2i+1;

typedef struct

{

    elemtype data[maxn];//存放二叉树的节点值

    int n;//元素个数

}sqbtree;

对于完全二叉树来说，顺序存储十分合适，能从分利用存储空间，但是对于一般二叉树而言，顺序存储使二叉树的插入删除等操作十分不方便。因此，我们引入链式存储：

链式存储：用一个链表来存一颗二叉树。节点定义如下：

typedef struct node

{

    elemtype data;//数据元素

    struct node *lchild;//指向左孩子

    struct node *rchild;//指向右孩子
}BiTree;

知道存储方法以后我们就可以建立二叉树了：（此处采用链式存储）

BiTree CreateBiTree(){

    char ch;

    BiTree T;

    scanf("%c",&ch);

    if(ch=='#')

        T=NULL;

    else{

        T = (BiTree)malloc(sizeof(BiTNode));

        T->data = ch;

        T->lchild = CreateBiTree();//递归建树（根左右：先序建树）

        T->rchild = CreateBiTree();

    }

    return T;//返回根节点

}

再来看看二叉树的三种遍历方式：

//先序遍历二叉树

void PreOrderTraverse(BiTree T){

    if(T){

       printf("%c",T->data);

       PreOrderTraverse(T->lchild);

       PreOrderTraverse(T->rchild);

    }

}

//中序遍历

void InOrderTraverse(BiTree T){

    if(T){

       PreOrderTraverse(T->lchild);

       printf("%c",T->data);

       PreOrderTraverse(T->rchild);

    }

}

//后序遍历

void PostOrderTraverse(BiTree T){

    if(T){

       PreOrderTraverse(T->lchild);

       PreOrderTraverse(T->rchild);

       printf("%c",T->data);

    }

}

以上均采用递归的方式遍历，下面是非递归的方式：（利用栈）

//栈的链式存储结构
typedef struct LNode
{
BiTree data;
struct LNode *next;
}LNode,*LinkList;

//进栈
Status Push(LinkList& S,BiTree T)
{
LinkList stack;
stack=(LinkList)malloc(sizeof(LNode));   //分配空间
stack->data=T;
stack->next=S->next;     //进栈
S->next=stack;
return OK;

}//Push
//出栈
Status Pop(LinkList &S,BiTree &T)
{
LinkList stack;
stack=S->next;    //出栈
S->next=stack->next; //栈顶指向下个元素
T=stack->data;
return OK;
}//Pop
//是否为空栈
Status StackEmpty(LinkList S)
{
if(S->next==NULL)
   return OK;
else
   return ERROR;
}

//先序非递归遍历 算法1
void PreOrder1(BiTree T)
{
BiTree Stack[MaxSize],p;    //定义栈
int top=0;
p=T;
while (p!=NULL||top>0)
{
   while(p!=NULL)
   {
    cout<<p->data<<" ";    //输出结点data
    Stack[top]=p;     //左树进栈
    top++;
    p=p->lchild;
   }
   if(top>0)
   {
    top--;
    p=Stack[top];
    p=p->rchild;
   }
}
cout<<endl;
}
//先序遍历非递归 算法2
void PreOrder2(BiTree b)
{
LinkList stack;
BiTree p;
p=(BiTree)malloc(sizeof(BiTree));


stack=(LinkList)malloc(sizeof(LinkList));
stack->next=NULL;
Push(stack,b);      //二叉树头结点进栈
while(!StackEmpty(stack))   //是否为空
{
   Pop(stack,p);     //出栈
   while (p)
   {
    cout<<p->data<<" ";   //输出当前指向结点
    if(p->rchild)Push(stack,p->rchild); //访问右指点
    p=p->lchild;
   }
        }
cout<<endl;
}
//后序非递归遍历
void PostOrder(BiTree T)
{
BiTree stack[MaxSize],p;
int top=0;
p=T;
do
{
   while (p!=NULL)
   {
    stack[++top]=p;
    p=p->lchild;
   }
   while (top>0&&stack[top]->rchild==p)
   {
    p=stack[top--];    //栈顶结点出栈
    cout<<p->data<<" ";   //访问p所指向的结点
   }
   if (top>0)
    p=stack[top]->rchild; //开始遍历右子树

}while(top>0);
cout<<endl;
}

二叉树的基本操作已经总结完了，下面是一些补充：

//计算叶子结点的个数
void CountLeaf(BiTree T,int &count)
{

if(T)
{
   if((!T->lchild)&&(!T->rchild))  
    count++;
   CountLeaf(T->lchild,count);   //左子树叶子个数
   CountLeaf(T->rchild,count);   //右子树叶子个数
}
}//CountLeaf
//计算双结点个数
void CountParent(BiTree T,int &count)
{
if(T)
{
if(T->lchild&&T->rchild)
   count++;
CountParent(T->lchild,count); //左子树双结点个数
CountParent(T->rchild,count); //右子树双结点个数
}
}
//计算二叉树结点个数
void Count(BiTree T,int &count)
{
if(T)
{
   Count(T->lchild,count);
   Count(T->rchild,count);
   count++;      //结点个数
}

}
//单结点个数
void CountChild(BiTree T,int &count)
{
if(T)
{
   if((T->lchild&&(!T->rchild))||(T->rchild&&(!T->lchild)))
    count++;
   CountChild(T->lchild,count);   //左子树单结点个数
   CountChild(T->rchild,count);   //右子树单结点个数
}
}
//计算树的高度
int Depth(BiTree T)
{ int depthval,depthLeft,depthRight;
if(!T) depthval=0;
else
{depthLeft=Depth(T->lchild);     //左子树高度
depthRight=Depth(T->rchild);     //右子树高度
depthval=1+(depthLeft>depthRight ?depthLeft:depthRight);   //取高度最高
}
return depthval;        //返回
}
//计算任意结点所在的层次
int NodeLevel(BiTree T,TElemType &p,int &count)
{
if(T==NULL)
   return 0;
if(T->data==p)
   return 1;
if(NodeLevel(T->lchild,p,count)||(NodeLevel(T->rchild,p,count)))
{
   count++;
   return 1;
}
// return 0;

}
//交换二叉树左右子树
void Exchange(BiTree &T)
{

BiTree temp;
if (T == NULL)
   return;
Exchange(T ->lchild);   //交换左子树
Exchange(T ->rchild);   //交换右子树
temp = NULL;
temp = T ->lchild;    //交换
T->lchild=T->rchild;
T->rchild=temp;

}
//判断两树是否相似
int LikeBiTree(BiTree T1,BiTree T2)
{
int like1,like2;
   if(T1==NULL&&T2==NULL)
    return 1;    
   else if(T1==NULL||T2==NULL)
    return 0;     
   else
   {
    like1=LikeBiTree(T1->lchild,T2->lchild);
    like2=LikeBiTree(T1->rchild,T2->rchild);
    return(like1&&like2);
   }

}//LikeBiTree

层次遍历二叉树（队列实现）

/*
二叉树的层次遍历
input:
2
10 5 4 -1 -1 -1 20 19 -1 -1 40 -1 -1
30 10 8 20 -1 -1 -1 -1 50 40 -1 45 -1 -1 -1
output:
10 5 20 4 19 40
30 10 50 8 40 20 45
*/
#include<iostream>
#include<queue>
using namespace std;
struct BTreeNode{
    //二叉树
    int data;
    BTreeNode *lchild;
    BTreeNode *rchild;
};
void LayerOrder(BTreeNode *t){
    //利用队列实现层次遍历，每次访问根结点，然后一次放入左结点和右结点（如果有的话）。
    if(t == NULL)return ;
    queue<BTreeNode*> q;
    BTreeNode *temp;
    q.push(t);
    while(!q.empty()){
        temp = q.front();
        q.pop();
        cout<<temp->data<<' ';
        if(temp->lchild != NULL)q.push(temp->lchild);
        if(temp->rchild != NULL)q.push(temp->rchild);
    }
}
void Create(BTreeNode *&t){
    //（测试用）以先序遍历构建二叉树
    int x;
    cin>>x;
    if(x == -1)
        t = NULL;
    else
    {
        t = new BTreeNode;
        t->data = x;
        Create(t->lchild);
        Create(t->rchild);
    }
}
int main(){
    BTreeNode *root = NULL;
    int t;
    cin>>t;
    while(t--)
    {
        Create(root);
        LayerOrder(root);
        cout<<endl;
    }
    return 0;
}

基础篇讲完啦~~~快下课了（上机课已经无聊到写博客了==造福人类吖*。*）