遍历二叉树（非递归法and递归法and层次遍历）

递归法遍历（先序、中序、后序）

#include 
#include 

typedef struct BiNode{
	int data;
	struct BiNode *right, *left;
}BiNode,*BiTree;

//初始化树 
BiTree CreatTree()
{
	BiTree T;
	T=(BiNode *)malloc(sizeof(BiNode));
	T->data=1;
	T->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->data=2;
	T->right=(BiNode *)malloc(sizeof(BiNode));
	T->right->data=3;
	T->left->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->left->data=4;
	T->left->right=NULL;
	T->right->left=T->right->right=NULL;
	T->left->left->left=T->left->left->right=NULL;	
	return T;
 }
  
void print(BiNode *T)
{
	printf("%d ",T->data);
	return;
}
//先序遍历 
void PerOrderTraverse(BiTree T)
{
	if(T!=NULL)
	{
	print(T);
	PerOrderTraverse(T->left);
	PerOrderTraverse(T->right);
	}
	return;
}
//中序遍历 
void MerOrderTraverse(BiTree T)
{
	if(T!=NULL)
	{
	MerOrderTraverse(T->left);
	print(T);
	MerOrderTraverse(T->right);
	}
	return;
}
//后序遍历 
void HerOrderTraverse(BiTree T)
{
	if(T!=NULL)
	{
	HerOrderTraverse(T->left);
	HerOrderTraverse(T->right);
	print(T);
	}
	return;
}

int main()
 {
 	BiTree Tree=CreatTree();
 	printf("先序遍历为:"); 
 	PerOrderTraverse(Tree);
	printf("\n");
 	printf("中序遍历为:"); 
 	MerOrderTraverse(Tree);
 	printf("\n");
 	printf("后序遍历为:"); 
 	HerOrderTraverse(Tree);
 	printf("\n");
  }  

层次法遍历

#include 
#include 
int rear=0,front=0;
typedef struct BiNode{
	int data;
	struct BiNode *right, *left;
}BiNode,*BiTree;

BiNode *a[20];   //采用顺序队列，初始化创建队列数组
//初始化树 
BiTree CreatTree()
{
	BiTree T;
	T=(BiNode *)malloc(sizeof(BiNode));
	T->data=1;
	T->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->data=2;
	T->right=(BiNode *)malloc(sizeof(BiNode));
	T->right->data=3;
	T->left->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->left->data=4;
	T->left->right=NULL;
	T->right->left=T->right->right=NULL;
	T->left->left->left=T->left->left->right=NULL;	
	return T;
 }
 //入队函数 
void EnQueue(BiNode *node)
 {
 	a[rear++]=node;
 	return;
 }
 //出队函数 
BiNode *DeQueue()
{
	return a[front++];
}
 //输出函数
 void print(BiTree T)
 {
 	printf("%d ",T->data);
	return; 
  } 
//层次遍历法

int main()
{
	printf("层次遍历法：\n"); 
	BiTree Tree=CreatTree();
	BiNode *p;
	EnQueue(Tree);
	while(rear!=front)
	{
		p=DeQueue();
		print(p);
		if(p->left!=NULL)
		EnQueue(p->left);
		if(p->right!=NULL)
		EnQueue(p->right);
	}
	return 0; 
} 

 非递归法遍历（先序、 中序、后序）

非递归先序法

#include 
#include 
int top=-1;
typedef struct BiNode{
	int data;
	struct BiNode *right, *left;
}BiNode,*BiTree;

//初始化树 
BiTree CreatTree()
{
	BiTree T;
	T=(BiNode *)malloc(sizeof(BiNode));
	T->data=1;
	T->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->data=2;
	T->right=(BiNode *)malloc(sizeof(BiNode));
	T->right->data=3;
	T->left->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->left->data=4;
	T->left->right=NULL;
	T->right->left=T->right->right=NULL;
	T->left->left->left=T->left->left->right=NULL;	
	return T;
 }
  
void print(BiNode *T)
{
	printf("%d ",T->data);
	return;
} 

void push(BiNode **a,BiNode *elem)//二级指针：a指向一个指向结构体地址的地址 
{
	a[++top]=elem;
	return; 
}
void pop()
{
	if(top==-1)
	{
		return;	
	}
	top--;
}
BiNode *getTop(BiNode **a)
{
	return a[top];
}
void PerOrderTraverse(BiTree T)
{
	BiNode *a[20];//二级指针：a指向一个空间大小为20的首地址，a[i]指向了结构体的地址 
	BiNode *p;
	push(a,T);
	while(top!=-1)
	{
		p=getTop(a);
		pop();
	 	while(p)
	 	{
	 		print(p);
	 		if(p->right)
	 		{
	 		push(a,p->right);
	 		}
			p=p->left; 
	 	}
	}
}

int main()
{
	BiTree Tree=CreatTree();
	printf("先序遍历：\n");
	PerOrderTraverse(Tree);
	return 0; 
} 

 

非递归中序法（两种）

#include 
#include 
int top=-1;
typedef struct BiNode{
	int data;
	struct BiNode *right, *left;
}BiNode,*BiTree;

//初始化树 
BiTree CreatTree()
{
	BiTree T;
	T=(BiNode *)malloc(sizeof(BiNode));
	T->data=1;
	T->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->data=2;
	T->right=(BiNode *)malloc(sizeof(BiNode));
	T->right->data=3;
	T->left->left=(BiNode *)malloc(sizeof(BiNode));
	T->left->left->data=4;
	T->left->right=NULL;
	T->right->left=T->right->right=NULL;
	T->left->left->left=T->left->left->right=NULL;	
	return T;
 }
  
void print(BiNode *T)
{
	printf("%d ",T->data);
	return;
} 

void push(BiNode **a,BiNode *elem)//二级指针：a指向一个指向结构体地址的地址 
{
	a[++top]=elem;
	return; 
}
void pop()
{
	if(top==-1)
	{
		return;	
	}
	top--;
}
BiNode *getTop(BiNode **a)
{
	return a[top];
}
// 
void MerOrderTraverse1(BiTree T)
{
	BiNode *a[20];//二级指针：a指向一个空间大小为20的首地址，a[i]指向了结构体的地址 
	BiNode *p;
	p=T;
	while(p||top!=-1)
	{
		if(p)
		{
			push(a,p);
			p=p->left;
		}
		else//左子树遍历到头,需要遍历右子树 
		{
			p=getTop(a);
			pop();
			print(p);
			p=p->right; 	
		}
	 } 
}

void MerOrderTraverse2(BiTree T)
{
	BiNode *a[20];//二级指针：a指向一个空间大小为20的首地址，a[i]指向了结构体的地址 
	BiNode *p;
	push(a, T);//根结点进栈
    while (top!=-1) \
	{//top!=-1说明栈内不为空，程序继续运行
        while ((p=getTop(a)) &&p)
		{//取栈顶元素，且不能为NULL
            push(a, p->left);//将该结点的左孩子进栈，如果没有左孩子，NULL进栈
        }
        pop();//跳出循环，栈顶元素肯定为NULL，将NULL弹栈
        if (top!=-1) 
		{
            p=getTop(a);//取栈顶元素
            pop();//栈顶元素弹栈
            print(p);
            push(a, p->right);//将p指向的结点的右孩子进栈
        }
    }
}

int main()
{
	BiTree Tree=CreatTree();
	printf("中序遍历1: ");
	MerOrderTraverse1(Tree);
	printf("\n");
	printf("中序遍历2: ");
	MerOrderTraverse2(Tree);
	return 0; 
}  

 

非递归后序法

#include 
#include 
#define TElemType int
int top=-1;//top变量时刻表示栈顶元素所在位置
//构造结点的结构体
typedef struct BiTNode
{
    TElemType data;//数据域
    struct BiTNode *lchild,*rchild;//左右孩子指针
}BiTNode,*BiTree;
//初始化树的函数
void CreateBiTree(BiTree *T)
{
    *T=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->data=1;
    (*T)->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->data=2;
    (*T)->lchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->lchild->rchild->data=5;
    (*T)->lchild->rchild->lchild=NULL;
    (*T)->lchild->rchild->rchild=NULL;
    (*T)->rchild->data=3;
    (*T)->rchild->lchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->lchild->data=6;
    (*T)->rchild->lchild->lchild=NULL;
    (*T)->rchild->lchild->rchild=NULL;
    (*T)->rchild->rchild=(BiTNode*)malloc(sizeof(BiTNode));
    (*T)->rchild->rchild->data=7;
    (*T)->rchild->rchild->lchild=NULL;
    (*T)->rchild->rchild->rchild=NULL;
    (*T)->lchild->lchild->data=4;
    (*T)->lchild->lchild->lchild=NULL;
    (*T)->lchild->lchild->rchild=NULL;
}
//弹栈函数
void pop( )
{
    if (top==-1) 
	{
        return ;
    }
    top--;
}
//模拟操作结点元素的函数，输出结点本身的数值
void displayElem(BiTNode* elem)
{
    printf("%d ",elem->data);
}
//后序遍历非递归算法
typedef struct SNode
{
    BiTree p;
    int tag;
}SNode;
//后序遍历使用的进栈函数
void postpush(SNode *a,SNode sdata)
{
    a[++top]=sdata;
}
//后序遍历函数
void PostOrderTraverse(BiTree Tree)
{
    SNode a[20];//定义一个顺序栈
    BiTNode * p;//临时指针
    int tag;
    SNode sdata;
    p=Tree;
    while (p||top!=-1) 
	{
        while (p)
		 {
            //为该结点入栈做准备
            sdata.p=p;
            sdata.tag=0;//由于遍历是左孩子，设置标志位为0
            postpush(a, sdata);//压栈
            p=p->lchild;//以该结点为根结点，遍历左孩子
        }
        sdata=a[top];//取栈顶元素
        pop();//栈顶元素弹栈
        p=sdata.p;
        tag=sdata.tag;
        //如果tag==0，说明该结点还没有遍历它的右孩子
        if (tag==0) 
		{
            sdata.p=p;
            sdata.tag=1;
            postpush(a, sdata);//更改该结点的标志位，重新压栈
            p=p->rchild;//以该结点的右孩子为根结点，重复循环
        }
        //如果取出来的栈顶元素的tag==1，说明此结点左右子树都遍历完了，可以调用操作函数了
        else{
            displayElem(p);
            p=NULL;
        }
    }
}
int main()
{
    BiTree Tree;
    CreateBiTree(&Tree);
    printf("后序遍历: \n");
    PostOrderTraverse(Tree);
}