二叉树的前序遍历、中序遍历、后续遍历 (包括递归、非递归,共六种)

原创 2012年03月24日 22:42:41

二叉树的前序遍历、中序遍历、后续遍历

(包括递归、非递归,共六种)

如有不当之处,望指正!!!

微笑


1、前序遍历(递归):

     算法实现一:

       #include <stdio.h>

#include <stdlib.h>

typedef struct BiTNode//定义结构体

{

       char data;

       struct BiTNode *lchild,*rchild;

}BiTNode,*BiTree;

void CreateBiTree(BiTree &T) //前序创建树

{

              char ch;

              scanf("%c",&ch);

              if(ch==' ')  T=NULL;

              else

              {

                     T=(struct BiTNode*)malloc(sizeof(struct BiTNode));

                     T->data=ch;

                     CreateBiTree(T->lchild);

                     CreateBiTree(T->rchild);

              }

}

int print(BiTree T)//前序遍历(输出二叉树)

{

              if(T==NULL)return 0;

              else  if(T->lchild==NULL&& T->rchild==NULL)return 1;

              else   returnprint(T->lchild)+print(T->rchild);

}

void main()//主函数

{

              BiTree T;

              CreateBiTree(T);

              printf("%d\n",print(T));

}

 

 

 

     算法实现二:

 

#include<stdio.h>

#include<stdlib.h>

struct BiTNode//定义结构体

{

    char data;

    structBiTNode *lchild,*rchild;

};

int num=0;

void CreatBiTree(struct BiTNode *&p) //前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ') p=NULL;

       else

       {

              p=(struct BiTNode *)malloc(sizeof(struct BiTNode));

              p->data=ch;

              CreatBiTree(p->lchild);

 

              CreatBiTree(p->rchild);

       }

}

void print(struct BiTNode *p) //前序遍历(输出二叉树)

{

       if(p!=NULL)

       {

              if(p->lchild==NULL&&p->rchild==NULL)

              else

              {

                     print(p->lchild);

                     print(p->rchild);

              }

       }

}

void main()//主函数

{

       struct BiTNode *p;

       CreatBiTree(p);

       print(p);

       printf("%d\n",num);

}

2、中序遍历(递归):

#include<stdio.h>

#include<stdlib.h>

struct BiTNode//定义结构体

{

    char data;

    struct BiTNode *lchild,*rchild;

};

void later(struct BiTNode *&p) //前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ')

              p=NULL;

       else

       {

              p=(struct BiTNode *)malloc(sizeof(struct BiTNode));

              p->data=ch;

              later(p->lchild);

              later(p->rchild);

       }

}

void print(struct BiTNode *p) //中序遍历(输出二叉树)

{

       if(p!=NULL)

       {

              print(p->lchild);

              printf("%c",p->data);

              print(p->rchild);

       }

       else

              printf(" ");

}

void main()//主函数

{

       struct BiTNode *p;

       later(p);

       print(p);

}

 

 

 

 

3、后序遍历(递归):

#include<stdio.h>

#include<stdlib.h>

struct BiTNode//定义结构体

{

    char data;

    struct BiTNode *lchild,*rchild;

};

void later(structBiTNode *&p)//前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ')

              p=NULL;

       else

       {

              p=(struct BiTNode*)malloc(sizeof(struct BiTNode));

              p->data=ch;

              later(p->lchild);

              later(p->rchild);

       }

}

void print(structBiTNode *p)//后序遍历(输出二叉树)

{

       if(p!=NULL)

       {

              print(p->lchild);

              print(p->rchild);

              printf("%c",p->data);

       }

       else

              printf("");

}

void main()//主函数

{/*检测:printf("到了吗");*/

       struct BiTNode *p;

       later(p);

       print(p);

}

 

 

 

 

4、前序遍历(非递归):

#include<stdio.h>

#include<stdlib.h>

struct BiTNode*stack[100];

struct BiTNode//定义结构体

{

    char data;

    struct BiTNode *lchild,*rchild;

};

void later(structBiTNode *&p)//前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ')

              p=NULL;

       else

       {

              p=(struct BiTNode*)malloc(sizeof(struct BiTNode));

              p->data=ch;

              later(p->lchild);

              later(p->rchild);

       }

}

void print(structBiTNode *p)//前序遍历(输出二叉树)

{

       int i=-1;

       while(1)

       {

              while(p!=NULL)

              {

                     stack[++i]=p->rchild;/*printf("ok?\n");*/

                     printf("%c",p->data);

                     p=p->lchild;

              }

              if(i!=-1)

              {

                     p=stack[i];

                     i--;

              }

              else

                     return;

       }

}

void main()//主函数

{

       struct BiTNode *p,*t;

       later(p);

       print(p);

}

 

 

 

5、中序遍历(非递归)

#include<stdio.h>

#include<stdlib.h>

struct BiTNode*stack[100];

struct BiTNode//定义结构体

{

    chardata;

    struct BiTNode *lchild,*rchild;

};

void later(structBiTNode *&p)//前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ')

              p=NULL;

       else

       {

              p=(struct BiTNode*)malloc(sizeof(struct BiTNode));

              p->data=ch;

              later(p->lchild);

              later(p->rchild);

       }

}

void print(structBiTNode *p)//中序遍历(输出二叉树)

{

       int i=-1;

       while(1)

       {

              while(p!=NULL)

              {

                     i++;

                     stack[i]=p;

                     p=p->lchild;

              }

              if(i!=-1)

              {

                     p=stack[i];

                     i--;

                     printf("%c",p->data);

                     p=p->rchild;

              }

       }

}

void main()//主函数

{

       struct BiTNode *p;

       later(p);

       print(p);

}

 

6、后续遍历(非递归):

#include<stdio.h>

#include<stdlib.h>

struct BiTNode*stack[100];

struct BiTNode//定义结构体

{

    char data;

    structBiTNode *lchild,*rchild;

};

void later(structBiTNode *&p)//前序创建树

{

       char ch;

       scanf("%c",&ch);

       if(ch==' ')

              p=NULL;

       else

       {

              p=(struct BiTNode*)malloc(sizeof(struct BiTNode));

              p->data=ch;

              later(p->lchild);

              later(p->rchild);

       }

}

void print(structBiTNode *p)//后序遍历(输出二叉树)

{

       int i=-1;

       while(1)

       {

              while(p!=NULL)

              {

                     stack[++i]=p;/*printf.0("ok?\n");*/

                     p=p->lchild;

              }

              if(i!=-1)

              {

            while(p==stack[i]->rchild||(p==stack[i]->lchild&&stack[i]->rchild==NULL))

            {

                p=stack[i--];

               printf("%c",p->data);

                if(i==-1)

                         return;

            }

           p=stack[i]->rchild;

              }

              else

                     return;

       }

}

int main()//主函数

{

       struct BiTNode *p,*t;

       later(p);

       print(p);

       printf("\n");

       system("pause");

       return 0;

}

 

供测试使用的数据

前序创建二叉树

中序

后序

/*AB D  C  */

 

BDAC

DBCA

/*ABC  D  EF  G  */

 

CBDAFEG

CDBFGEA

 

 

相关文章推荐

二叉树非递归中序遍历

  • 2014年06月19日 11:36
  • 2KB
  • 下载

leetcode | 二叉树的前序遍历、中序遍历、后续遍历的非递归实现

Binary Tree Preorder Traversal:https://leetcode.com/problems/binary-tree-preorder-traversal/ Binary...

二叉树的非递归前序遍历

二叉树的遍历有递归和非递归两种,递归的已经写过,就写了一下非递归的前序遍历。中序和后续整好了一起贴另一篇。二叉树遍历,节点位置一会移动了几次一会又回来了,进进出出,所以用栈比较适合。(我瞎说的,因为我...

二叉树的前序遍历(非递归)

二叉树的前序遍历(非递归)算法的关键是:在前序遍历过某节点的整个左子树后,如何找到该节点的右子树的根指针。 如下图所示: 在前序遍历过程中,栈s和当前根指针T的变化情况以及树中各节点的访问次序如下...

二叉树的中序遍历(非递归)

在二叉树的中序遍历中,访问节点的操作发生在该节点的左子树遍历完毕并准备遍历右子树时,所以,在遍历过程中遇到某节点时并不能立即访问它,而是将它压栈,等到它的左子树遍历完毕后,再从栈中弹出并访问之。 中...

利用非递归方法实现二叉树的中序遍历

#include #include #define N 7 using namespace std; typedef struct node { struct node *leftChild; ...
  • stpeace
  • stpeace
  • 2012年11月02日 10:45
  • 1071

图解二叉树非递归版的中序遍历算法

你会学到什么 讨论的问题是什么 这个问题相关的概念和理论 非递归版中序遍历算法 代码思考 算法技巧 实现代码 快照 评价算法 总结 欢迎关注算法思考与应用公众号 你会学到什么?树的递归遍历算法很容易理...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:二叉树的前序遍历、中序遍历、后续遍历 (包括递归、非递归,共六种)
举报原因:
原因补充:

(最多只允许输入30个字)