二叉树

二叉树模板

结构体定义

struct node
{
    char data;//节点为字母,若为数字就是int data;
    node *lc;//左儿子
    node *rc;//右儿子
};

先序遍历

int flag;
//先序遍历
void preorder(node *root)
{
    if(root)
    {
        //if(flag!=0) cout<<" ";//当输入为数字时控制空格输出
        cout<<root->data;
        //flag=1;//当输入为数字时控制空格输出
        preorder(root->lc);
        preorder(root->rc);
    }
}

int main()
{
    node *root;
    root=create();//建树
    //flag=0;//当输入为数字时控制空格输出
    preorder(root);
    cout<<endl;
}

中序遍历

int flag;
//中序遍历 
void inorder(node *root)
{
    if(root)
    {
        inorder(root->lc);
        //if(flag!=0) cout<<" ";//当输入为数字时控制空格输出
        cout<<root->data;
        //flag=1;//当输入为数字时控制空格输出
        inorder(root->rc);
    }
}

int main()
{
    node *root;
    root=create();//建树
    //flag=0;//当输入为数字时控制空格输出
    inorder(root);
    cout<<endl;
}

后序遍历

//后序遍历 
void postorder(node *root)
{
    if(root)
    {
        postorder(root->lc);
        postorder(root->rc);
        //if(flag!=0) cout<<" ";//当输入为数字时控制空格输出
        cout<<root->data;
        //flag=1;//当输入为数字时控制空格输出
    }
}

int main()
{
    node *root;
    root=create();//建树
    //flag=0;//当输入为数字时控制空格输出
    postorder(root);
    cout<<endl;
}

层序遍历

//以层序遍历的方式，寻找叶子节点 
void cengxu(node *root)
{
    queue<node*>q;
    if(root) q.push(root);
    node *qq;
    while(!q.empty())
    {
        qq=q.front();
        q.pop();
        if(qq->lc) q.push(qq->lc);
        if(qq->rc) q.push(qq->rc);
        //if(flag!=0) cout<<" ";//当输入为数字时控制空格输出
        cout<<qq->data; 
        //flag=1;//当输入为数字时控制空格输出
    }
}

int main()
{
    node *root;
    root=create();//建树
    //flag=0;//当输入为数字时控制空格输出
    cengxu(root);
    cout<<endl;
}

已知先序 / 中序 / 后序，建树

char st[10010];
int ans;
node *pre_create()//先序
//node *in_create()//中序
//node *post_create()//后序
{
    node *root;
    //,代表空节点 
    if(st[++ans]==',') root=NULL;
    else
    {
        root=new node;
        //按先序建树
        root->data=st[ans];
        root->lc=pre_create();
        root->rc=pre_create();

        //按中序建树
        //root->lc=pre_create();
        //root->data=st[ans];
        //root->rc=pre_create();

        //按后序建树
        //root->lc=pre_create();
        //root->rc=pre_create();
        //root->data=st[ans];
    }
    return root;
}

int main()
{
    cin>>st;
    ans=-1;
    node *root;
    root=create();//建树函数
}

已知中序和后序，建树

char pre[10010];
char mid[10010];
char las[10010];
//按中序和后序建树
node *in_post_create(int len,char *mid,char*las)
{
    node *root;
    int i;
    if(len==0) return NULL;
    root=new node;
    root->data=las[len-1];
    for(i=0;i<len;i++)
    {
        if(mid[i]==las[len-1]) break;
    }
    root->lc=in_post_create(i,mid,las);
    root->rc=in_post_create(len-i-1,mid+i+1,las+i);
    return root;
}

int main()
{
    cin>>mid>>las;
    int len=strlen(mid);
    node *root;
    root=in_post_create(len,mid,las);
}

已知先序和中序，建树

char pre[10010];
char mid[10010];
char las[10010];
//按先序和中序建树
node *pre_in_create(int len,char *pre,char *mid)
{
    node *root;
    int i; 
    if(len==0) return NULL;
    root=new node;
    root->data=pre[0];
    for(i=0;i<len;i++)
    {
        if(mid[i]==pre[0]) break;
    }
    root->lc=pre_in_create(i,pre+1,mid);
    root->rc=pre_in_create(len-i-1,pre+i+1,mid+i+1);
    return root;
}

int main()
{
    cin>>pre>>mid;
    int len=strlen(pre);
    node *root;
    root=pre_in_create(len,pre,mid);
}

已知层序，建树

node *cengxu_create()
{
    int num;//0代表空节点 
    node *root,*temp;
    node *queue[100];
    int head=0,tail=0;
    cin>>num;
    if(num==0) return NULL;
    else
    {
        root=(node*)malloc(sizeof(node));
        root->data=num;
        root->lc=NULL;
        root->rc=NULL;
        queue[tail++]=root;
    }
    while(head<tail)
    {
        cin>>num;
        if(num==0) queue[head]->lc=NULL;//空节点不入队
        else
        {
            temp=(node*)malloc(sizeof(node));
            temp->data=num;
            temp->lc=NULL;
            temp->rc=NULL;
            queue[head]->lc=temp;
            queue[tail++]=temp;
        }
        cin>>num;
        if(num==0) queue[head]->rc=NULL;//空节点不入队
        else
        {
            temp=(node*)malloc(sizeof(node));
            temp->data=num;
            temp->lc=NULL;
            temp->rc=NULL;
            queue[head]->rc=temp;
            queue[tail++]=temp;
        }
        head++;
    }
    return root;
}

int main()
{
    node *root;
    root=cengxu_create();
}

求二叉树的高度

//递归求树的深度 
int depth(node *root)
{
    if(root == NULL) return 0;
    else
    {
        int m=depth(root->lc);
        int n=depth(root->rc);
        return max(m,n)+1;
    }
}

int main()
{
    node *root;
    root=create();//建树函数
    int deep=depth(root);
    cout<<deep<<endl;
}

求叶子节点个数 && 层序输出叶子节点

int cnt;
//以层序遍历的方式，寻找叶子节点 
void cengxu(node *root)
{
    queue<node*>q;
    if(root) q.push(root);
    node *qq;
    while(!q.empty())
    {
        qq=q.front();
        q.pop();
        if(qq->lc) q.push(qq->lc);
        if(qq->rc) q.push(qq->rc);
        //左右子节点都为空，即为叶子节点 
        //叶子节点个数 
        if(!qq->lc && !qq->rc) cnt++;
        //层序输出叶子节点 
        if(!qq->lc && !qq->rc) cout<<qq->data;
    }
}

int main()
{
    cnt=0;
    node *root;
    root=create();//建树函数
    //flag=0;//当输入为数字时控制空格输出
    cengxu(root);
    cout<<cnt<<endl;
}