二叉树的遍历

 

#include<string.h>

 #include<ctype.h>

 #include<malloc.h> // malloc()等

 #include<limits.h> // INT_MAX等

 #include<stdio.h> // EOF(=^Z或F6),NULL

 #include<stdlib.h> // atoi()

 #include<io.h> // eof()

 #include<math.h> // floor(),ceil(),abs()

 #include<process.h> // exit()

 #include<iostream.h> // cout,cin

 // 函数结果状态代码

 #define TRUE 1

 #define FALSE 0

 #define OK 1

 #define ERROR 0

 #define INFEASIBLE -1

 typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

 typedef int Boolean; // Boolean是布尔类型,其值是TRUE或FALSE

 #include"BiTree.h"

 void main()

 {

        BiTree D;

        printf("建立二叉树，以#字符表示空指针\n");

        CreateBiTree(D);

        printf("先序递归遍历\n");

        PreOrderTraverse(D);

        printf("\n");

        printf("中序递归遍历\n");

        InOrderTraverse(D);

        printf("\n");

        printf("后序递归遍历\n");

        PostOrderTraverse(D);

        printf("\n");

        printf("层次遍历\n");

        LevelOrderTraverse(D);

        printf("\n");

        printf("先序非递归遍历\n");

        PreOrderTraverse2(D);

        printf("\n");

        printf("中序非递归遍历\n");

        InOrderTraverse2(D);

        printf("\n");

        printf("后序非递归遍历\n");

         LastOrderTraverse2(D);

         printf("\n");

 }

// 二叉树的二叉链表存储(的基本操作(22个)，包括算法6.1～6.4

// 二叉树的二叉链表存储表示

typedef  char TElemType;

 typedef struct BiTNode

 {

   TElemType data;

  struct BiTNode *lchild,*rchild; // 左右孩子指针

  int k;//标记

 }BiTNode,*BiTree;

 

 void CreateBiTree(BiTree &T)

 { // 算法6.4：按先序次序输入二叉树中结点的值(可为字符型或整型，在主程中定义)，

   // 构造二叉链表表示的二叉树T。变量Nil表示空(子)树。有改动

   TElemType ch;

   scanf("%c",&ch);

   if(ch=='#') // 空

   {

     T=NULL;

        return ;

        

   }

   else

   {

     T=(BiTree)malloc(sizeof(BiTNode)); // 生成根结点

     if(!T)

       exit(OVERFLOW);

     T->data=ch;

     CreateBiTree(T->lchild); // 构造左子树

     CreateBiTree(T->rchild); // 构造右子树

   }

 }

 

 

 void PreOrderTraverse(BiTree T)

 { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数。算法6.1，有改动

   // 操作结果：先序递归遍历T，对每个结点调用函数Visit一次且仅一次

   if(T) // T不空

   {

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

     PreOrderTraverse(T->lchild); // 再先序遍历左子树

     PreOrderTraverse(T->rchild); // 最后先序遍历右子树

   }

 }

 

 void InOrderTraverse(BiTree T)

 { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数

   // 操作结果：中序递归遍历T，对每个结点调用函数Visit一次且仅一次

   if(T)

   {

     InOrderTraverse(T->lchild); // 先中序遍历左子树

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

     InOrderTraverse(T->rchild); // 最后中序遍历右子树

   }

 }

 

voidPostOrderTraverse(BiTree T)

 { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数

   // 操作结果：后序递归遍历T，对每个结点调用函数Visit一次且仅一次

   if(T)

   {

     PostOrderTraverse(T->lchild); // 先后序遍历左子树

     PostOrderTraverse(T->rchild); // 最后后序遍历右子树

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

   }

 }

 

 

 

 

 int BiTreeDepth(BiTree T)

 { // 初始条件：二叉树T存在。操作结果：返回T的深度

   int i,j;

   if(!T)

     return 0; // 空树深度为0

   if(T->lchild)

     i=BiTreeDepth(T->lchild); // i为左子树的深度

   else

     i=0;

   if(T->rchild)

     j=BiTreeDepth(T->rchild); // j为右子树的深度

   else

     j=0;

   return i>j?i+1:j+1; // T的深度为其左右子树的深度中的大者+1

 }

 typedef BiTree QElemType; // 设队列元素为二叉树的指针类型

 #include"LinkQueue.h"  // 链队列的基本操作

 

   void LevelOrderTraverse(BiTree T)

 { // 初始条件：二叉树T存在，Visit是对结点操作的应用函数

   // 操作结果：层序递归遍历T(利用队列)，对每个结点调用函数Visit一次且仅一次

   LinkQueue q;

   QElemType a;

   if(T)

   {

     InitQueue(q); // 初始化队列q

     EnQueue(q,T); // 根指针入队

     while(!QueueEmpty(q)) // 队列不空

     {

       DeQueue(q,a); // 出队元素(指针),赋给a

 

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

       if(a->lchild!=NULL) // a有左孩子

        EnQueue(q,a->lchild);// 入队a的左孩子

       if(a->rchild!=NULL) // a有右孩子

        EnQueue(q,a->rchild); // 入队a的右孩子

     }

     printf("\n");

   }

 }

 typedef BiTree SElemType; // 设栈元素为二叉树的指针类型

 #include"SqStack.h"// 顺序栈的基本操作

StatusPreOrderTraverse2(BiTree T)

{

    SqStack s;

    BiTree P=T;

    InitStack(s);

     while ( P!=NULL || !StackEmpty(s))

        {

        if (P!=NULL)

              {

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

        Push(s,P); //访问完之后将根节点入栈

        P=P->lchild;

              }

 

        else

              {

        Pop(s,P);

        P=P->rchild;

              }

 

        }

        return 1;

}

 

 void InOrderTraverse2(BiTree T)

 { // 采用二叉链表存储结构，Visit是对数据元素操作的应用函数。算法6.2，有改动

   // 中序遍历二叉树T的非递归算法(利用栈)，对每个数据元素调用函数Visit

  SqStack s;

   InitStack(s);

   SElemType p;

   if(!T)

         printf("该树为空树！\n");

   p=T;

   while( p||!StackEmpty(s))

         {

                while(p)

                {//延根节点一直向左访问树的节点，直到树的左尽头，找到树的最左端

                      Push(s,p);

                      p=p->lchild;

                }

         

               if(!StackEmpty(s))

               {//从书的最左端回溯式的中序遍历

            Pop(s,p);

                 printf("%c ",p->data);//出栈时访问树节点的数据域

                 p=p->rchild;

               

               }

         }

    printf("\n");

 }

 

 

voidLastOrderTraverse2(BiTree T)

{

 

 

   SqStack S;

   InitStack(S);//栈的初始化

   SElemType p;

   p=T;

   if(!T)

         printf("该树为空树！\n");

   else

   {

        while(p || !StackEmpty(S))

              {

                     while(p)

                     {//延根节点一直向左访问树的节点，直到树的左尽头

                        Push(S,p);

                        p->k=0; //进栈的树节点的flag全部设为0，未被访问过

                        p=p->lchild;

                     }

               GetTop(S,p);//获取栈顶元素

                     while(!StackEmpty(S)&&p->k==1)

                     {//判断栈顶元素是否被访问过，被访问过则打印出该元素

                        Pop(S,p);

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

                        if(!StackEmpty(S))

                          GetTop(S,p);//获取栈顶元素

                        else

                              exit(0);

                     }

                     if(p)//此时的p是未被访问过的

                     {

                         p->k=1;//设置其已被访问

                p=p->rchild;//访问其右孩子

                     }

                 while(p)

                     {

                        Push(S,p);//树的某个节点的右孩子节点进栈

                        p->k =0;//设置未被访问

                        p=p->lchild;//再先访问左孩子，直到最

                     }

              }

   }

}