二叉树的性质和常用操作代码集合

二叉树的性质和常用操作代码集合

性质：

二叉树的性质和常用代码操作集合

性质1:在二叉树的第i层上至多有2^i-1个结点

性质2：深度为k的二叉树至多有2^k - 1个结点

性质3：对任意一棵二叉树T，若终端结点数为n0，而其度数为2的结点数为n2，则n0 = n2 + 1

满二叉树：深度为k且有2^-1个结点的树
完全二叉树：深度为k，结点数为n的二叉树，如果其结点1~n的位置序号分别与等高的满二叉树的结
点1~n的位置序号一一对应，则为完全二叉树。

性质4：具有n的结点的完全二叉树深度为log2n + 1

性质5：对于具有n个结点的完全二叉树，如果按照从上到下和从左到右的顺序对二叉树中的所有结点
从1开始顺序编号，则对于任意的序号为i的结点有：
1.如i = 1，则序号为i的结点为根结点，无双亲结点；如i>1，则序号为i的结点的双亲结点序号为
i/2。
2.如2i>n，则序号为i的结点无左孩子;如2i<=n，则序号为i的结点的左孩子结点的序号为2i。
3.如2i+1>n，则序号为i的结点无右孩子，如2i+1<=n，则序号为i的结点的右孩子序号为2i+1。

1.宏定义：
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define datatypebt char
#define MAXNODE 1024
#define BOTTOMNODE 1024
#define FULLNODE 1024
2.结构体：
typedef struct bitnode
{
    datatypebt data;
    struct bitnode *lchild,*rchild;
}Bitnode,*Bitree;
3.基本函数：
Bitree Initiate_Bitree()
/*初始化二叉树函数1.先决条件:无2.函数作用:初始化一棵空的带头结点的二叉树,返回头结点的地址*/
{
    Bitnode *bt;
    bt=(Bitnode *)malloc(sizeof(Bitnode));
    bt->lchild=NULL;
    bt->rchild=NULL;
    return bt;
}
Bitnode *Create_Bitree(datatypebt x,Bitnode *lbt,Bitnode *rbt)
/*建立二叉树函数1.先决条件:无2.函数作用:生成一棵以x为根结点数据域信息,以lbt,rbt为左右子树的二叉树,返回新二叉树的地址*/
{
    Bitree p;
    p=(Bitnode *)malloc(sizeof(Bitnode));
    p->data=x;
    p->lchild=lbt;
    p->rchild=rbt;
    return p;
}
void Precreate_Bitree(Bitree *T)
/*先序构建二叉树函数1.先决条件:T是子树根结点的地址2.函数作用:以先序遍历序列构造二叉树链表存储的二叉树T*/
{
    char ch;
    scanf("%c",&ch);
    if(ch==‘0‘)
        *T=NULL;
    else
    {
        (*T)=(Bitnode *)malloc(sizeof(Bitnode));
        (*T)->data=ch;
        Precreate_Bitree(&(*T)->lchild);
        Precreate_Bitree(&(*T)->rchild);
    }
}
void Preinorder_Bitree(Bitree *t,char preod[],int i,int j,char inod[],int k,int h)
/*先中序恢复树函数1.先决条件:t是子树根结点的地址2.函数作用:preod[i..j]为先序子序列,inod[k..h]为中子序序列,根据先序序列和中序序列恢复二叉树t*/
{
    int m;
    *t=(Bitnode *)malloc(sizeof(Bitnode));
    (*t)->data=preod[i];
    m=k;
    while(inod[m]!=preod[i])
        m++;
    if(m==k)
        (*t)->lchild=NULL;
    else
        Preinorder_Bitree(&(*t)->lchild,preod,i+1,i+m-k,inod,k,m-1);
    if(m==h)
        (*t)->rchild=NULL;
    else
        Preinorder_Bitree(&(*t)->rchild,preod,i+m-k+1,j,inod,m+1,h);
}
int Recovery_Bitree(Bitree bt,char preod[],char inod[],int n)
/*先中序恢复树函数1.先决条件:初始化二叉树,bt为头结点,拥有Preinorder_Bitree()函数2.函数作用:根据先序和中序序列恢复二叉树bt,成功返回1*/
{
    if(n<=0)
        bt->lchild=NULL;
    else Preinorder_Bitree(&bt->lchild,preod,0,n-1,inod,0,n-1);
    return 1;
}
void Postfree_Bitree(Bitree p)
/*后序释放函数1.先决条件:p为子树根结点的地址2.函数作用:释放子树p的全部空间*/
{
    if(p==NULL)
        return ;
    Postfree_Bitree(p->lchild);
    Postfree_Bitree(p->rchild);
    free(p);
}
int Empty_Bitree(Bitree bt)
/*判空函数1.先决条件:初始化二叉树,bt为头结点2.函数作用:若二叉树bt为空,则返回1,否则返回0*/
{
    if(bt->lchild==NULL)
        return 1;
    else return 0;
}
Bitnode *Root_Bitree(Bitree bt)
/*求根函数1.先决条件:初始化二叉树,bt为头结点2.函数作用:求二叉树bt的根结点,返回根结点的地址,若bt为空二叉树,则函数返回NULL*/
{
    return bt->lchild;
}
Bitnode *Search_Bitree(Bitree bt,datatypebt x)
/*查找函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:在二叉树bt中查找值为x的数据元素,成功返回其地址,找不到返回NULL*/
{
    Bitree p=NULL;
    if(bt)
    {
        if(bt->data==x)
            return bt;
        if(bt->lchild)
            p=Search_Bitree(bt->lchild,x);
        if(p)
            return p;
        if(bt->rchild)
            p=Search_Bitree(bt->rchild,x);
        if(p)
            return p;
    }
    return NULL;
}
int InsertL_Bitree(Bitnode *parent,datatypebt x)
/*左插入函数1.先决条件:无2.函数作用:在二叉树中的parent所指结点和其左子树之间插入数据元素为x的结点,成功返回1*/
{
    Bitnode *p;
    if(parent==NULL)
    {
        printf("插入出错.\n");/*此句可以根据情况删除*/
        return 0;
    }
    p=(Bitnode *)malloc(sizeof(Bitnode));
    p->data=x;
    p->lchild=NULL;
    p->rchild=NULL;
    if(parent->lchild==NULL)
        parent->lchild=p;
    else
    {
        p->lchild=parent->lchild;
        parent->lchild=p;
    }
    return 1;
}
int InsertR_Bitree(Bitnode *parent,datatypebt x)
/*右插入函数1.先决条件:无2.函数作用:在二叉树中的parent所指结点和其右子树之间插入数据元素为x的结点,成功返回1*/
{
    Bitnode *p;
    if(parent==NULL)
    {
        printf("插入出错.\n");/*此句可以根据情况删除*/
        return 0;
    }
    p=(Bitnode *)malloc(sizeof(Bitnode));
    p->data=x;
    p->lchild=NULL;
    p->rchild=NULL;
    if(parent->rchild==NULL)
        parent->rchild=p;
    else
    {
        p->rchild=parent->rchild;
        parent->rchild=p;
    }
    return 1;
}
int DeleteL_Bitree(Bitnode *parent)
/*左删除函数1.先决条件:parent为子树的根结点,拥有Postfree_Bitree()函数2.函数作用:在二叉树中删除parent的左子树,成功返回1*/
{
    Bitnode *p;
    if(parent==NULL||parent->lchild==NULL)
    {
        printf("删除出错.\n");/*此句可以根据情况删除*/
        return NULL;
    }
    p=parent->lchild;
    parent->lchild=NULL;
    Postfree_Bitree(p);
    return 1;
}
int DeleteR_Bitree(Bitnode *parent)
/*右删除函数1.先决条件:parent为子树的根结点,拥有Postfree_Bitree()函数2.函数作用:在二叉树中删除parent的右子树,成功返回1*/
{
    Bitnode *p;
    if(parent==NULL||parent->rchild==NULL)
    {
        printf("删除出错.\n");/*此句可以根据情况删除*/
        return NULL;
    }
    p=parent->rchild;
    parent->rchild=NULL;
    Postfree_Bitree(p);
    return 1;
}
Bitnode *Parent_Bitree(Bitree bt,Bitnode *x)
/*求双亲函数1.先决条件:初始化二叉树bt,bt是子树根或头结点;2.函数作用:求二叉树bt中结点x的双亲结点,若结点x是二叉树的根结点或二叉树bt中无结点x,则返回NULL*/
{
    Bitnode *p=NULL;
    if(bt)
    {
        if(bt->lchild==x||bt->rchild==x)
        {
            p=bt;
            return p;
        }
        p=Parent_Bitree(bt->lchild,x);
        if(p)
            return p;
        p=Parent_Bitree(bt->rchild,x);
        if(p)
            return p;
    }
    return NULL;
}
void Visit_Bitree(Bitnode *p)
/*访问函数1.先决条件:无2.函数作用:输出一个二叉树结点p的数据*/
{
    if(p)
        printf("%c ",p->data);
}
int Countleaf_Bitree(Bitree bt)
/*统计叶子数函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:统计二叉树bt中叶子结点的个数,返回值为bt的叶子数*/
{
    if(bt==NULL)
        return 0;
    if(bt->lchild==NULL&&bt->rchild==NULL)
        return 1;
    return Countleaf_Bitree(bt->lchild)+Countleaf_Bitree(bt->rchild);
}
void Preorder_Bitree(Bitree bt)
/*先序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法先序遍历二叉树bt*/
{
    if(bt==NULL)
        return;
    Visit_Bitree(bt);
    Preorder_Bitree(bt->lchild);
    Preorder_Bitree(bt->rchild);
}
void Inorder_Bitree(Bitree bt)
/*中序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法中序遍历二叉树bt*/
{
    if(bt==NULL)
        return;
    Inorder_Bitree(bt->lchild);
    Visit_Bitree(bt);
    Inorder_Bitree(bt->rchild);
}
void Postorder_Bitree(Bitree bt)
/*后序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点;2.函数作用:用递归方法后序遍历二叉树bt*/
{
    if(bt==NULL)
        return ;
    Postorder_Bitree(bt->lchild);
    Postorder_Bitree(bt->rchild);
    Visit_Bitree(bt);
}
int NRPreorder_Bitree(Bitree bt)
/*非递归先序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归先序遍历二叉树bt,空树返回0,非空树返回1,栈溢出返回-1*/
{
    Bitnode *p,*s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
    int top=-1;
    if((p=bt)==NULL)
    {
        printf("此为空二叉树.\n");/*此句可以根据情况删除*/
        return 0;
    }
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            Visit_Bitree(p);
            top++;
            if(top>=MAXNODE)
            {
                printf("栈溢出.\n");
                return -1;
            }
            s[top]=p;
            p=p->lchild;
        }

        p=s[top];
        top--;
        p=p->rchild;
    }
    return 1;
}
int NRInorder_Bitree(Bitree bt)
/*非递归中序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归中序遍历二叉树bt,空树返回0,非空树返回1,栈溢出返回-1*/
{
    Bitnode *p,*s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
    int top=-1;
    if((p=bt)==NULL)
    {
        printf("此为空二叉树.\n");/*此句可以根据情况删除*/
        return 0;
    }
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            top++;
            if(top>=MAXNODE)
            {
                printf("栈溢出.\n");
                return -1;
            }
            s[top]=p;
            p=p->lchild;
        }
        p=s[top];
        Visit_Bitree(p);
        top--;
        p=p->rchild;
    }
    return 1;
}
int NRPostorder_Bitree(Bitree bt)
/*非递归后序遍历函数1.先决条件:初始化二叉树,bt是子树根或头结点2.函数作用:非递归后序遍历二叉树bt,p为当前结点指针,q为前驱结点指针,空树返回0,非空树返回1,栈溢出返回-1*/
{
    Bitnode *s[MAXNODE];/*MAXNODE最少是二叉树的层数h*/
    int top;
    Bitnode *p,*q;
    q=NULL;
    p=bt;
    if(!p)
        return 0;
    top=-1;
    while(p!=NULL||top!=-1)
    {
        while(p!=NULL)
        {
            top++;
            if(top>=MAXNODE)
            {
                printf("栈溢出.\n");
                return -1;
            }
            s[top]=p;
            p=p->lchild;
        }
        if(top>-1)
        {
            p=s[top];
            if(p->rchild==NULL||p->rchild==q)
            {
                Visit_Bitree(p);
                q=p;
                top--;
                p=NULL;
            }
            else
                p=p->rchild;
        }
    }
    return 1;
}
int Levelorder_Bitree(Bitree bt)
/*层次遍历二叉树函数1.先决条件:bt是子树根结点2.函数作用:层次遍历二叉树bt,队满溢出返回-1,空树返回0,非空树返回1*/
{
    Bitnode *sq[BOTTOMNODE];/*MAXNODE最少是2^(h-1),其中h为层数*/
    int front=-1,rear=0,num=0;
    if(bt==NULL)
        return 0;
    if(num<MAXNODE)
    {
        sq[rear]=bt;
        num++;
    }
    else
    {
        printf("队满.\n");/*可视情况删除此句*/
        return -1;
    }
    while(num)
    {
        front=(front+1)%MAXNODE;
        num--;
        Visit_Bitree(sq[front]);
        if(sq[front]->lchild)
            if(num==MAXNODE)
            {
                printf("队满.\n");/*可视情况删除此句*/
                return -1;
            }
            else
            {
                rear=(rear+1)%MAXNODE;
                sq[rear]=sq[front]->lchild;
                num++;
            }
        if(sq[front]->rchild)
            if(num==MAXNODE)
            {
                printf("队满.\n");/*可视情况删除此句*/
                return -1;
            }
            else
            {
                rear=(rear+1)%MAXNODE;
                sq[rear]=sq[front]->rchild;
                num++;
            }
    }
    return 1;
}
int Posttreedepth_Bitree(Bitree bt)
/*后序二叉树高度函数1.先决条件:bt为子树根结点2.函数作用:通过后序遍历求二叉树bt的高度,返回二叉树的高度*/
{
    int hl,hr,max;
    if(bt!=NULL)
    {
        hl=Posttreedepth_Bitree(bt->lchild);
        hr=Posttreedepth_Bitree(bt->rchild);
        max=hl>hr?hl:hr;
        return max+1;
    }
    else
        return 0;
}
void Pretreedepth_Bitree(Bitree bt,int h,int *depth)
/*前序二叉树高度函数1.先决条件:bt是子树根结点,h为bt结点所在层次,初值为1,depth为当前求得的最大层次,调用前初值为0;
2.函数作用:通过先序遍历求二叉树bt高度*/
{
    if(bt!=NULL)
    {
        if(h>*depth)
            *depth=h;
        Pretreedepth_Bitree(bt->lchild,h+1,depth);
        Pretreedepth_Bitree(bt->rchild,h+1,depth);
    }
}
void Pretreelevel_Bitree(Bitree bt,int h)
/*前序二叉树打印层号函数1.先决条件:bt是子树根结点,h为bt结点所在层次,初值为1;2.函数作用:通过先序遍历打印二叉树bt中结点和层号*/
{
    if(bt!=NULL)
    {
        printf("%d %c\n",h,bt->data);
        Pretreelevel_Bitree(bt->lchild,h+1);
        Pretreelevel_Bitree(bt->rchild,h+1);
    }
}
void Pretreenode_Bitree(Bitree bt,int *num)
/*前序二叉树结点函数1.先决条件:bt是子树根结点,num为累计的结点数,调用前初值为0;2.函数作用:通过先序遍历求二叉树的结点数目num*/
{
    if(bt!=NULL)
    {
        *num=*num+1;
        Pretreenode_Bitree(bt->lchild,num);
        Pretreenode_Bitree(bt->rchild,num);
    }
}
int Print1_Bitree(Bitree bt)
/*按树状打印二叉树函数1.先决条件:bt是子树根结点,拥有Posttreedepth_Bitree()函数2.函数作用:按树状打印二叉树bt*/
{
    int i,j,k,n,flag=1,kongge,chuduigeshu=1;
    Bitnode *sq[FULLNODE],*temp;/*FULLNODE最少为满二叉树结点数+1*/
    int rear,front,num;
    if(bt==NULL)
        return 0;
    front=rear=FULLNODE-1;
    num=0;
    if(num==FULLNODE)
    {
        printf("队满.\n");/*可视情况删除此句*/
        return -1;
    }
    else
    {
        rear=(rear+1)%FULLNODE;
        sq[rear]=bt;
        num++;
    }
    n=Posttreedepth_Bitree(bt);
    for(i=1,kongge=1;i<n;i++)
        kongge=kongge*2;
    for(i=1;i<=n;i++)
    {
        j=1;
        while(j<=chuduigeshu)
        {
            if(flag==1)
            {
                for(k=1;k<kongge;k++)
                    printf(" ");/*因树结点的数据长度不同而不同*/
                front=(front+1)%FULLNODE;
                temp=sq[front];
                num--;
                if(temp)
                {
                    printf("%c",temp->data);/*因二叉树数据类型不同而不同*/
                    if(num==FULLNODE-1)
                    {
                        printf("队满.\n");/*可视情况删除此句*/
                        return -1;
                    }
                    else
                    {
                        rear=(rear+1)%FULLNODE;
                        sq[rear]=temp->lchild;
                        rear=(rear+1)%FULLNODE;
                        sq[rear]=temp->rchild;
                        num=num+2;
                    }
                }
                else
                {
                    printf(" ");/*因树结点的数据长度不同而不同*/
                    if(num==FULLNODE-1)
                    {
                        printf("队满.\n");/*可视情况删除此句*/
                        return -1;
                    }
                    else
                    {
                        rear=(rear+1)%FULLNODE;
                        sq[rear]=NULL;
                        rear=(rear+1)%FULLNODE;
                        sq[rear]=NULL;
                        num=num+2;
                    }
                }
                j++;
            }
            else
                for(k=1;k<=kongge;k++)
                    printf(" ");/*因树结点的数据长度不同而不同*/
            flag=-flag;
        }
        printf("\n");
        kongge=kongge/2;
        chuduigeshu=chuduigeshu*2;
        flag=1;
    }
    return 1;
}
void Print2_Bitree(Bitree bt,int nlayer)
/*按竖向树状打印二叉树函数1.先决条件:bt为子树根结点,nlayer为bt指向结点所在层次,初值为0;2.函数作用:按竖向树状打印二叉树bt*/
{
    if(bt==NULL)
        return ;
    Print2_Bitree(bt->rchild,nlayer+1);
    for(int i=0;i<nlayer;i++)
        printf(" ");/*因树结点的数据长度不同而不同*/
    printf("%c\n",bt->data);/*因树结点的数据类型不同而不同*/
    Print2_Bitree(bt->lchild,nlayer+1);
}