二叉树的遍历

来源：互联网发布：net.cn域名编辑：程序博客网时间：2024/05/21 06:42

二叉树的链式存储结构是一类重要的数据结构，其形式定义如下：

[cpp] view plaincopy
//二叉树结点  
typedef struct BiTNode{  
    //数据  
    char data;  
    //左右孩子指针  
    struct BiTNode *lchild,*rchild;  
}BiTNode,*BiTree;  

二叉树的创建：

通过读入一个字符串，建立二叉树的算法如下：

[cpp] view plaincopy
//按先序序列创建二叉树  
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;  
}  

二叉树的遍历：

遍历是对树的一种最基本的运算，所谓遍历二叉树，就是按一定的规则和顺序走遍二叉树的所有结点，使每一个结点都被访问一次，而且只被访问一次。由于二叉树是非线性结构，因此，树的遍历实质上是将二叉树的各个结点转换成为一个线性序列来表示。

递归算法：

[cpp] view plaincopy
//输出  
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);  
    }  
}  

非递归算法：

<1>先序遍历：

【思路】：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历T的右子树。

[cpp] view plaincopy
/* 先序遍历(非递归) 
   思路：访问T->data后，将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，再先序遍历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;  
        }  
    }//while  
}  

<2>中序遍历

【思路】：T是要遍历树的根指针，中序遍历要求在遍历完左子树后，访问根，再遍历右子树。
先将T入栈，遍历左子树；遍历完左子树返回时，栈顶元素应为T，出栈，访问T->data，再中序遍历T的右子树。

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

<3>后序遍历

【思路】：T是要遍历树的根指针，后序遍历要求在遍历完左右子树后，再访问根。需要判断根结点的左右子树是否均遍历过。

[cpp] view plaincopy
//后序遍历(非递归)  
typedef struct BiTNodePost{  
    BiTree biTree;  
    char tag;  
}BiTNodePost,*BiTreePost;  
  
void PostOrder2(BiTree T){  
    stack<BiTreePost> stack;  
    //p是遍历指针  
    BiTree p = T;  
    BiTreePost BT;  
    //栈不空或者p不空时循环  
    while(p != NULL || !stack.empty()){  
        //遍历左子树  
        while(p != NULL){  
            BT = (BiTreePost)malloc(sizeof(BiTNodePost));  
            BT->biTree = p;  
            //访问过左子树  
            BT->tag = 'L';  
            stack.push(BT);  
            p = p->lchild;  
        }  
        //左右子树访问完毕访问根节点  
        while(!stack.empty() && (stack.top())->tag == 'R'){  
            BT = stack.top();  
            //退栈  
            stack.pop();  
            BT->biTree;  
            printf("%c ",BT->biTree->data);  
        }  
        //遍历右子树  
        if(!stack.empty()){  
            BT = stack.top();  
            //访问过右子树  
            BT->tag = 'R';  
            p = BT->biTree;  
            p = p->rchild;  
        }  
    }//while  
}  

<4>层次遍历

【思路】：按从顶向下，从左至右的顺序来逐层访问每个节点，层次遍历的过程中需要用队列。

[cpp] view plaincopy
//层次遍历  
void LevelOrder(BiTree T){  
    BiTree p = T;  
    //队列  
    queue<BiTree> queue;  
    //根节点入队  
    queue.push(p);  
    //队列不空循环  
    while(!queue.empty()){  
        //对头元素出队  
        p = queue.front();  
        //访问p指向的结点  
        printf("%c ",p->data);  
        //退出队列  
        queue.pop();  
        //左子树不空，将左子树入队  
        if(p->lchild != NULL){  
            queue.push(p->lchild);  
        }  
        //右子树不空，将右子树入队  
        if(p->rchild != NULL){  
            queue.push(p->rchild);  
        }  
    }  
}  

一、已知二叉树的前序序列和中序序列，求解树。

1、确定树的根节点。树根是当前树中所有元素在前序遍历中最先出现的元素。

2、求解树的子树。找出根节点在中序遍历中的位置，根左边的所有元素就是左子树，根右边的所有元素就是右子树。若根节点左边或右边为空，则该方向子树为空；若根节点左边和右边都为空，则根节点已经为叶子节点。

3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。

//由前序和中序求后序
#include <iostream>
#include <string.h>
using namespace std;
typedef struct node{
char data;
node *left,*right;
}*tree;
char preorder[100],inorder[100];
/* 由前序、中序构造树
* i: 子树的前序序列字符串的首字符在preorder[]中的下标
* j: 子树的中序序列字符串的首字符在inorder[]中的下标
* len: 子树的字符串序列的长度
*/
void CreatTree(tree &t,int i,int j,int len){
if (len<=0)
return;
if (t==NULL){
t=new node;
t->left=t->right=NULL;
}
t->data=preorder[i];
int m=strchr(inorder,preorder[i])-inorder; //preorder[i]在inorder[]第几个字符
CreatTree(t->left,i+1,j,m-j);
CreatTree(t->right,i+(m-j)+1,m+1,len-1-(m-j));
}
/*后序遍历*/
void PostOrder(tree t){
if(t!=NULL){
PostOrder(t->left); //访问左子结点
PostOrder(t->right); //访问右子结点
cout<<(t->data); //访问根节点
}
}
int main(){
while (cin>>preorder>>inorder){
tree t=NULL;
int len=strlen(preorder);
CreatTree(t,0,0,len);
PostOrder(t);
cout<<endl;
}
return 0;
}

二、已知二叉树的后序序列和中序序列，求解树。

1、确定树的根。树根是当前树中所有元素在后序遍历中最后出现的元素。

3、递归求解树。将左子树和右子树分别看成一棵二叉树，重复1、2、3步，直到所有的节点完成定位。

#include <iostream>
#include <string.h>
using namespace std;
typedef struct node{
char data;
node *left,*right;
}*tree;
char inorder[100],post[100];
/* 由中序和后序构造树
* i: 子树的后序序列字符串的首字符在post[]中的下标
* j: 子树的中序序列字符串的首字符在inorder[]中的下标
* len: 子树的字符串序列的长度
*/
void CreatTree(tree &t,int i,int j,int len){
if (len<=0)
return;
if (t==NULL){
t=new node;
t->left=t->right=NULL;
}
t->data=post[i];
int m=strchr(inorder,post[i])-inorder; //post[i]在inorder[]第几个字符
CreatTree(t->left,i-1-(len-1-(m-j)),j,m-j); //m-j左子树的长度,len-1-(m-j)右子树的长度
CreatTree(t->right,i-1,m+1,len-1-(m-j));
}
/*前序遍历*/
void PreTravelTree(tree t){
if (t){
cout<<t->data;
PreTravelTree(t->left);
PreTravelTree(t->right);
}
}
int main(){
while (cin>>inorder>>post){
tree t=NULL;
int len=strlen(inorder);
CreatTree(t,len-1,0,len);
PreTravelTree(t);
cout<<endl;
}
return 0;
}

0 0