二叉树的建立与遍历

二叉树的建立与遍历

• 二叉树遍历分为三种方法：先序遍历，中序遍历，后序遍历
• 先序遍历：

1. 访问根节点
2. 遍历左子树
3. 遍历右子树

• 中序遍历：

4. 遍历左子树
5. 访问根节点
6. 遍历右子树

• 后序遍历：

7. 遍历左子树
8. 遍历右子树
9. 访问根节点

#include<stdio.h>
#include<stdlib.h>
# define MAXSIZE 500


//二叉链表
typedef struct Node     
{
	char data;
	struct Node* lchild;
	struct Node* rchild;
}BiTNode,*BiTree;



//栈
typedef struct          
{
   BiTNode data[MAXSIZE];
   int top;    
}SeqStack;



SeqStack* s;

//队列
typedef struct
{
   BiTNode data[MAXSIZE];
   int rear, front;      //队头队尾指针
}CSeQueue;


CSeQueue* Q;


void CreatTree(BiTree *T);     // 建立链表
void PostOrder(BiTree T);     // 后序递归遍历
void PreOrder(BiTree T);      //非递归先序遍历
void LevelOrder(BiTree T);     //按层次遍历
SeqStack* InitSeq();     //初始化栈
void Push(SeqStack* s, BiTNode *c);    //进栈
void Pop(SeqStack* s,BiTree *x);    //出栈
int Empty(SeqStack* s);     //判空
CSeQueue* InitQueue();      //初始化队列
int EmptySeQueue(CSeQueue* q);     //判队空
void InSeQueue(CSeQueue* q, BiTNode* c);     //入队
void OutSeQueue(CSeQueue* q, BiTree* x);     //出队



void main()
{
	BiTree root = NULL;
    printf("Please input your data:");
	CreatTree(&root);    //建立二叉树
    printf("Postorder:");
    PostOrder(root);     //后序递归遍历二叉树
    printf("\n");
    printf("Preorder:");
    PreOrder(root);      //先序非递归遍历二叉树
    printf("\n");
    printf("LevelOrder:");
    LevelOrder(root);     //按层次遍历二叉树
    printf("\n");
}


//初始化栈
SeqStack* InitSeq()     
{
   s = (SeqStack*)malloc(sizeof(SeqStack));
   s->top = -1;
   return s;
}


//初始化循环队列
CSeQueue* InitQueue()
{
   Q = (CSeQueue*)malloc(sizeof(CSeQueue));
   Q->front = Q->rear = MAXSIZE - 1;
   return Q;
}



//入队
void InSeQueue(CSeQueue* q, BiTNode* c)
{
   if ((q->rear + 1) % MAXSIZE == q->front)
   {
       printf("队满");
       return;
   }
   else
   {
       q->rear = (q->rear + 1) % MAXSIZE;
       q->data[q->rear] = *c;
   }
}



//出队
void OutSeQueue(CSeQueue* q, BiTree* x)
{
   if (EmptySeQueue(q) == 1)
   {
       printf("队空");
       return;
   }
   else
   {
       q->front = (q->front + 1) % MAXSIZE;
       *x = &q->data[q->front];    //队头
   }
}



//栈判空
int Empty(SeqStack* s)
{
   if (s->top == -1) 
       return 1;
   else 
       return 0;
}



//判队空
int EmptySeQueue(CSeQueue* q)
{
   if (q->rear == q->front)
       return 1;
   else
       return 0;
}


//进栈
void Push(SeqStack* s, BiTNode *c)
{
   if (s->top == MAXSIZE - 1)
   {
       return;
   }
   s->top++;
   s->data[s->top] = *c;
}


//出栈
void Pop(SeqStack* s,BiTree *x)
{
   if (Empty(s))
   {
       return;
   }
   *x = &s->data[s->top];
   s->top--;
}


//建立二叉链表
void CreatTree(BiTree *T)      
{
   char s;
   scanf("%c", &s);
   if (s == '#')
   {
       *T = NULL;
   }
   else
   {
       *T = (BiTNode*)malloc(sizeof(BiTNode)); //生成结点
       if (!(*T))
       {
           printf("申请空间失败\n");
       }
       (*T)->data = s;
       CreatTree(&(*T)->lchild);
       CreatTree(&(*T)->rchild);
   }
}


//后序递归遍历
void PostOrder(BiTree T)     
{
   if (T)
   {
       PostOrder(T->lchild);
       PostOrder(T->rchild);
       printf("%c", T->data);
   }
}


//先序非递归遍历二叉树
void PreOrder(BiTree T)    
{
   SeqStack* s = InitSeq();    //初始化栈
   BiTree p;
   p = T;
   while (p != NULL || !Empty(s))
   {
       if (p != NULL)
       {
           printf("%c", p->data);     //打印根节点
           Push(s, p);     //进栈
           p = p->lchild;
       }
       else
       {
           Pop(s, &p);      //出栈
           p = p->rchild;
       }
   }
}


//按层次遍历
void LevelOrder(BiTree T)
{
   BiTree p;
   Q = InitQueue();
   InSeQueue(Q, T);    //入队根节点
   while (!EmptySeQueue(Q))
   {
       OutSeQueue(Q, &p);
       printf("%c", p->data);
       if (p->lchild != NULL)
       {
           InSeQueue(Q, p->lchild);    //入队左孩子
       }
       if (p->rchild != NULL)
       {
           InSeQueue(Q, p->rchild);     //入队右孩子
       }
   }
}