二叉树

一.给你一棵树，关于这棵树的储存和各种遍历：

#include<bits/stdc++.h>

using namespace std;

//二叉树节点
typedef struct BiTNode{
    char data;//数据
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//按先序序列创建二叉树
int CreateBiTree(BiTree &T)
{
    char data;
    //按先序次序依次输入二叉树中节点的值（字符）
    //“#”表示空树
    scanf("%c",&data);
    if(data == '#')
        T=NULL;
    else{
        T=(BiTree)malloc(sizeof(BiTNode));
        //生成根节点
        T->data=data;
        //构造左子树
        CreateBiTree(T->lchild);
        //构造右子树
        CreateBiTree(T->rchild);
    }
    return 0;
}

/////////////////////////////////////////////////
//////////////////递归输出遍历/////////////////////////
//输出
void Visit(BiTree T)
{
    if(T->data!='#')
        printf("%c",T->data);
}

//先序遍历
void PreOrder(BiTree T)
{
    if(T!=NULL){
        //输出根节点
        Visit(T);
        //访问左子节点
        PreOrder(T->lchild);
        //访问右子节点
        PreOrder(T->rchild);
    }
}

//中序遍历
void InOrder(BiTree T)
{
    if(T!=NULL){
        //访问左子节点
        InOrder(T->lchild);
        //输出根节点
        Visit(T);
        //访问右子节点
        InOrder(T->rchild);
    }
}

//后序遍历
void PostOrder(BiTree T)
{
    if(T!=NULL){
        //访问左子节点
        PostOrder(T->lchild);
        //访问右子节点
        PostOrder(T->rchild);
        //输出根节点
        Visit(T);
    }
}

//////////////////////////////////////////////////////
////////////非递归输出遍历/////////////////////////////
//先序遍历
void PreOrder2(BiTree T){
    stack<BiTree> stack;
    //p是遍历指针
    BiTree p = T;
    //栈不空或者p不空时循环
    while(p || !stack.empty()){
        if(p != NULL){
            //存入栈中
            stack.push(p);
            //访问根节点
            printf("%c ",p->data);
            //遍历左子树
            p = p->lchild;
        }
        else{
            //退栈
            p = stack.top();
            stack.pop();
            //访问右子树
            p = p->rchild;
        }
    }
}

//中序遍历
void InOrder2(BiTree T)
{
    stack<BiTree>sta;
    //p是遍历指针
    BiTree p=T;
    //栈不为空时或p不为空时循环
    while(p!=NULL||!sta.empty()){
        if(p!=NULL){
            //存入栈中
            sta.push(p);
            //遍历左子树
            p=p->lchild;
        }
        else{
            //退栈，访问节点
            p=sta.top();
            sta.pop();
            printf("%c ",p->data);
            //访问右子树
            p=p->rchild;
        }
    }
}

//后序遍历
typedef struct BiTNodePost{
    BiTree biTree;
    char tag;
}BiTNodePost,*BiTreePost;

void PostOrder2(BiTree T)
{
    stack<BiTreePost>sta;
    //p是遍历指针
    BiTree p=T;
    BiTreePost BT;
    //栈不为空或p不为空时循环
    while(p!=NULL || !sta.empty()){
        //遍历左子树
        while(p!=NULL){
            BT=(BiTreePost)malloc(sizeof(BiTNodePost));
            BT->biTree = p;
            //访问左子树
            BT->tag = 'L';
            sta.push(BT);
            p=p->lchild;
        }
        //左右子树访问完毕访问根节点
        while(!sta.empty() && (sta.top()->tag == 'R')){
            BT = sta.top();
            //退栈
            sta.pop();
            BT->biTree;
            printf("%c ",BT->biTree->data);
        }
        //遍历右子树
        if(!sta.empty()){
            BT = sta.top();
            //访问过右子树
            BT->tag ='R';
            p=BT->biTree;
            p=p->rchild;
        }
    }
}
//////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
//层次遍历
void LevelOrder(BiTree T)
{
    BiTree p=T;
    //队列
    queue<BiTree>q;
    //根节点入队
    q.push(p);
    while(!q.empty()){
        p=q.front();
        q.pop();
        printf("%c ",p->data);
        if(p->lchild!=NULL)
            q.push(p->lchild);
        if(p->rchild!=NULL)
            q.push(p->rchild);
    }
}

int main()
{
    BiTree T;
    CreateBiTree(T);
    printf("先序遍历：\n");
    PreOrder(T);
    printf("\n");
    printf("先序遍历(非递归)：\n");
    PreOrder2(T);
    printf("\n");
    printf("中序遍历：\n");
    InOrder(T);
    printf("\n");
    printf("中序遍历(非递归)：\n");
    InOrder2(T);
    printf("\n");
    printf("后序遍历：\n");
    PostOrder(T);
    printf("\n");
    printf("后序遍历(非递归)：\n");
    PostOrder2(T);
    printf("\n");
    printf("层次遍历：\n");
    LevelOrder(T);
    printf("\n");
    return 0;
}

这代码非原创，来自：https://blog.csdn.net/shufac/article/details/26979517

二：由二叉树的前序，中序构造二叉树并储存，然后输出二叉树镜像的层次遍历。

题目：https://www.patest.cn/contests/gplt/L2-011

//由中序，前序构造二叉树
#include<bits/stdc++.h>

using namespace std;

int n;
int a[100],b[100];

typedef struct BiTNode{
    int data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

int CreateBiTree(BiTree &T, int la, int ra, int lb, int rb)
{
    if(la>ra){
        T=NULL;
        return 0;
    }
    int t;
    for(t=lb;t<=rb;t++){
        if(b[t]==a[la])
            break;
    }
    if(t<=rb){
        T=(BiTree)malloc(sizeof(BiTNode));
        T->data=a[la];
        CreateBiTree(T->rchild,la+t+1-lb,ra,t+1,rb);
        CreateBiTree(T->lchild,la+1,la+t-lb,lb,t-1);
    }
    return 0;
}

void LevelOrder(BiTree &T)
{
    BiTree p=T;
    int flag=0;
    //队列
    queue<BiTree>q;
    //根节点入队
    q.push(p);
    while(!q.empty()){
        p=q.front();
        q.pop();
        if(flag)
            printf(" %d",p->data);
        else{
            printf("%d",p->data);
            flag=1;
        }
        if(p->rchild!=NULL)
            q.push(p->rchild);
        if(p->lchild!=NULL)
            q.push(p->lchild);
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&b[i]);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    BiTree T;
    CreateBiTree(T,0,n-1,0,n-1);
    LevelOrder(T);
    return 0;
}

三.由二叉树的后序，中序构造二叉树并储存，然后输出二叉树的层次遍历。

题目：https://www.patest.cn/contests/gplt/L2-006

//由中序，后序构造二叉树
#include<bits/stdc++.h>

using namespace std;

int n;
int a[100],b[100];

typedef struct BiTNode{
    int data;
    struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

int CreateBiTree(BiTree &T, int la, int ra, int lb, int rb)
{
    if(la>ra){
        T=NULL;
        return 0;
    }
    int t;
    for(t=lb;t<=rb;t++){
        if(b[t]==a[ra])
            break;
    }
    if(t<=rb){
        T=(BiTree)malloc(sizeof(BiTNode));
        T->data=a[ra];
        CreateBiTree(T->rchild,ra-rb+t,ra-1,t+1,rb);
        CreateBiTree(T->lchild,la,ra-rb+t-1,lb,t-1);
    }
    return 0;
}

void LevelOrder(BiTree &T)
{
    BiTree p=T;
    int flag=0;
    //队列
    queue<BiTree>q;
    //根节点入队
    q.push(p);
    while(!q.empty()){
        p=q.front();
        q.pop();
        if(flag)
            printf(" %d",p->data);
        else{
            printf("%d",p->data);
            flag=1;
        }
        if(p->lchild!=NULL)
            q.push(p->lchild);
        if(p->rchild!=NULL)
            q.push(p->rchild);
    }
}

int main()
{
    scanf("%d",&n);
    for(int i=0;i<n;i++)
        scanf("%d",&a[i]);
    for(int i=0;i<n;i++)
        scanf("%d",&b[i]);
    BiTree T;
    CreateBiTree(T,0,n-1,0,n-1);
    LevelOrder(T);
    return 0;
}