二叉树的建立和遍历

Date：2019-06-28 13:51:23

二叉树的建立

• 注意一下中序和层序建树

//给出当前先序序列PreL, PreL+1, ..., Pre(L+numLeft), Pre(L+numLeft+1), ..., PreR
//给出当前中序序列InL, InL+1, ..., In(K-1), InK, In(k+1), ..., InR
BiTnode* CreatePreIn(int preL, int preR, int inL, int inR)
{
    if(preL > preR)
        return NULL;    //先序序列长度小于0

    BiTnode *root = new BiTnode;
    root->data = pre[preL];
    int k;
    for(int k=inL; k<=inR; k++)
        if(in[k] == pre[preL])  //在中序序列中找到根节点
            break;
    int numLeft = k - inL;      //由中序序列得到左子树结点的个数

    //左子树的先序区间为[preL+1, preL+numLeft], 左子树的中序区间为[inL, k-1];
    root->lchild = CreatePreIn(preL+1, preL+numLeft, inL, k-1);
    //右子树的先序区间为[preL+numLeft+1, preR], 右子树的中序区间为[k+1, inR];
    root->rchild = CreatePreIn(preL+numLeft+1, preR, k+1, inR);

    return root;
}

//给出当前后序序列PostL, PostL+1, ..., Post(L+numLeft-1), Post(L+numLeft), ..., Pre(R-1), PreR
//给出当前中序序列InL, InL+1, ..., In(k-1), Ink, In(k+1), ..., InR
BiTnode* CreatePostIn(int postL, int postR, int InL, int inR)
{
    if(postL > postR)
        return NULL;

    BiTnode *root = new BiTnode;
    root->data = post[postR];
    int k;
    for(int k=inL; k<=inR; k++)
        if(In[k] == post[postR])
            break;
    int numleft = k - inL;

    root->lchild = CreatePostIn(postL, postL+numLeft-1, inL, k-1);
    root->rchild = CreatePostIn(postL+numLeft, postR-1, k+1, inR);

    return root;
}

//给出当前中序序列InL, ..., In(k-1), Ink, In(k+1), ..., InR
//给出当前层次序列layerL, ..., layerR
BiTnode* CreateLayerIn(int inL, int inR, int layerL, int layerR)
{
    if(inL > inR)
        return NULL;
    BiTnode *root = new BiTnode;

    int i, j;
    for(int i=layerL; i<=layerR; i++)
    {
        int x=0;
        for(int j=inL; j<=inR; j++)
        {
            if(layer[i] = in[j])
            {
                b = 1;
                root->data = in[j];
                break;
            }
        }
        if(b)   break;
    }
    root->lchild = CreateLayerIn(inL, j-1, layerL, layerR);
    root->rchild = CreateLayerIn(j+1, inR, layerL, layerR);

    return root;
}

二叉树的遍历

//先序
void PreOrder(BiTnode* T)
{
    if(T == NULL)
        return;
    //visit(T);
    PreOrder(T->lchild);
    PreOrder(T->rchild);
}

//先序非递归
#include <stack>
using namespace std;
void PreOrder(BiTnode* T)
{
    stack<BiTnode*> s;
    BiTnode *p = T;
    while(p || !s.empty())
    {
        if(p)
        {
            //visit(p);
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            s.pop();
            p = p->rchild;
        }
    }
}

//中序
void InOrder(BiTnode* T)
{
    if(T == NULL)
        return
    InOrder(T->lchild);
    //visit(T);
    InOrder(T->rchild);
}

//中序非递归
#include <stack>
using namespace std;
void InOrder2(BiTnode* T)
{
    stack<BiTnode*> s;
    BiTnode *p = T;
    while(p || !s.empty())
    {
        if(p)
        {
            s.push(p);
            p = p->lchild;
        }
else
{
p = s.top();
//visit(p);
s.pop();
p = p->rchild;
}
}
}

//后序
void PostOrder(BiTnode* T)
{
    if(T == NULL)
        return;
    PostOrder(T->lchild);
    PostOrder(T->rchild);
    //visit(T);
}

//后序非递归
void PostOrder(BiTnode* T)
{
    stack<BiTnode*> s;
    BiTnode *p, *r=NULL;
    while(p || !s.empty())
    {
        if(p)
        {
            s.push(p);
            p = p->lchild;
        }
        else
        {
            p = s.top();
            if(p->rchild && p->rchild!=r)
            {
                p = p->rchild;
                s.push(p);
                p = p->lchild;
            }
            else
            {   //p出栈时，栈内为根节点到p的路径，以此可以求解公共结点等
                //visit(p);
                s.pop();
                r = p;
                p = NULL;
            }
        }
    }
}

//层次
#include <queue>
using namespace std;
void LevelOrder(BiTnode* T)
{
    queue<BiTnode*> q;      //队列中存放BiTnode变量的地址，这样就可以通过访问地址去修改原元素
    T->level = 1;           //记录结点深度
    q.push(T);
    while(!q.empty())
    {
        BiTnode *p = q.front();
        q.pop();
        //visit(p);
        if(p->lchild)
        {
            p->lchild->level = p->level + 1;       //计算各结点深度
            q.push(p->lchild);
        }
        if(p->rchild)
        {
            p->rchild->level = p->level + 1;
            q.push(p->rchild);
        }
    }
}

多叉树的静态表示

//存储结构：孩子表示法
#include <vector>
using namespace std;
const int M = 1e3;
struct node
{
    int layer;  //结点深度
    int data;
    vector<int> children;
}tree[M];

//若结点不涉及数据域，可以简化结点结构
vector<int> child[M];

//插入结点
int index=0;
int NewNode(int x)
{
    tree[index].data = x;
    tree[index].children.clear();
    return index++;
}

//遍历
void PreOrder(int root)
{
    printf("%d ", tree[root].data);     //先根遍历
    for(int i=0; i<tree[root].children.size(); i++)
        PreOrder(tree[root].children[i]);
    Printf("%d ", tree[root].data);     //后根遍历
}

//层序遍历
#include <queue>
using namespace std;
void LayerOrder(int root)
{
    queue<int> q;
    tree[root].layer = 0;
    q.push(root);
    while(!q.empty())
    {
        root = q.front();
        q.pop();
        printf("%d ", tree[root].data);
        for(int i=0; i<tree[root].children.size(); i++)
        {
            int child = tree[root].children[i];
            tree[child].layer = tree[root].layer+1;
            q.push(child);
        }
    }
}