二叉树的操作&&重点：几种遍历方式

基本操作

#include<stdio.h>
#include<queue>
#include<string.h>
using namespace std;

struct node{
    int data;//数据域
    node* lchild;//指向左子树根节点的指针
    node* rchild;//指向右子树根节点的指针
};

node* newNode(int v){//新建结点
    node* Node=new node;//申请一个node型变量的地址空间
    Node->data=v;//结点权值为v
    Node->lchild=Node->rchild=NULL;//初始状态下默认没有左右孩子
    return Node;//返回新建结点的地址
}

void search(node* root,int x,int newdata){//二叉树结点的查找与修改
    if(root==NULL) return;//空树，死胡同（递归边界）
    if(root->data==x){//找到数据域为x的结点，把它修改为newnode
        root->data=newdata;
    }
    search(root->lchild,x,newdata);//往左子树搜索x（递归式）
    search(root->rchild,x,newdata);//往右子树搜索x(递归式）
}

void insert(node* &root,int x){//注意根节点指针在root要使用引用，否则插入不成功
    if(root==NULL){//空树，说明查找失败，也即插入位置（递归边界）
        root=newNode(x);//注意newNode是自己建立的函数
        return;
    }
    if(...){
        insert(root->lchild,x);//往左子树递归（递归式）
    }else{
        insert(root->rchild,x);//往右子树递归（递归式）
    }
}

node* Create(int data[],int n){
    node* root=NULL;//新建空根节点root
    for(int i=0;i<n;i++){
        insert(root,data[i]);
    }
    return root;
}

遍历操作

void preorder(node* root){
    if(root==NULL) return;//达到空树，递归边界
    printf("%d\n",root->data);
    preorder(root->lchild);
    preorder(root->rchild);
}

void inorder(node* root){
    if(root==NULL) return;
    inorder(root->lchild);
    printf("%d\n",root->data);
    inorder(root->rchild);
}

void postorder(node* root){
    if(root==NULL) return;//到达空树，递归边界
    postorder(root->lchild);
    postorder(root->rchild);
    printf("%d\n",root->data);
}

void LayerOrder(node* root){
    queue<node*> q;//注意队列里存放的是地址
    q.push(root);//将根节点地址入队
    while(!q.empty()){
        node* now=q.front();//取出队首元素
        q.pop();
        printf("%d",now->data);//访问队首元素
        if(now->lchild!=NULL) q.push(now->lchild);//左子树非空
        if(now->rchild!=NULL) q.push(now->rchile);//右子树非空
    }
}

题目：已知一棵二叉树的后序遍历和中序遍历序列，求这棵二叉树的层序遍历序列。

cpp
#include<stdio.h>
#include<string.h>
#include<queue>
#include<algorithm>

using namespace std;

const int maxn = 50;

struct node {
    int data;
    node *lchild;
    node *rchild;
};

int pre[maxn], in[maxn], post[maxn];//分别代表前序、中序、后序
int n;//结点个数

//当前二叉树的后序序列为[postL,postR],中序序列为[inL,inR]
//create函数返回构建出的二叉树的根节点地址
node *create(int postL, int postR, int inL, int inR) {
    if (postL > postR) return NULL;//后序序列长度小于等于0时，直接返回
    node *root = new node;//新建一个新的结点，用来存放当前二叉树的根节点
    root->data = post[postR];//新结点的数据域为根节点的值
    int k;
    for (k = inL; k <= inR; k++) {
        if (in[k] == post[postR]) break;//在中序序列中找到in[k]==pre[L]的结点
    }
    int numLeft = k - inL;//左子树的结点个数
    //返回左子树的根节点地址，赋值给root的左指针
    root->lchild = create(postL, postL + numLeft - 1, inL, k - 1);
    //返回右子树的根节点地址，赋值给root的右指针
    root->rchild = create(postL + numLeft, postR - 1, k + 1, inR);
    return root;//返回根节点的地址
}

int num = 0;//已输出结点的个数
void BFS(node *root) {
    queue<node *> q;//注意队列里存放的是地址
    q.push(root);//将根节点的地址入队
    while (!q.empty()) {
        node *now = q.front();//取出队首元素
        q.pop();
        printf("%d", now->data);//访问队首元素
        num++;
        if (num < n) printf(" ");
        if (now->lchild != NULL) q.push(now->lchild);//左子树非空
        if (now->rchild != NULL) q.push(now->rchild);//右子树非空
    }
}

int main() {
    scanf("%d", &n);
    for (int i = 0; i < n; i++) scanf("%d", &post[i]);
    for (int i = 0; i < n; i++) scanf("%d", &in[i]);
    node *root = create(0, n - 1, 0, n - 1);
    BFS(root);
    return 0;
}