二叉树遍历的实现

递归实现

先序遍历

代码实现

存储状态

中序遍历

后序遍历

算法分析

实质

复杂度

非递归算法实现

中序遍历

层次遍历

原理

实现

代码整合：

//二叉链式存储 ：数据域+左右指针域 
typedef struct node{
	int data;
	node  *lchild,*rchild;// 
}bitnode,*bitree;
//bitree bt;

//递归遍历:本质都是一个访问路径，只不过输出时机不同而已 
//先序遍历 
1.非空判断
2.根-访问 左右-不断递归调用自身遍历左右子树
void preoder(bitree bt){
	bitnode *p=bt;//不要直接对树进行振作，最好定义一个新指针来振作 
	if(p!=NULL){
		cout<<p->data<<endl;
		preoder(p->lchild);
		preoder(p->rchild);
	}
} 
//中序遍历 
1.非空判断
2. 左 根-访问 右-不断递归调用自身遍历左右子树
void inoder(bitree bt){
	bitnode *p=bt;//不要直接对树进行振作，最好定义一个新指针来振作 
	if(p!=NULL){
		inoder(p->lchild);
		cout<<p->data<<endl;
	    inoder(p->rchild);
	}
} 
//后序遍历 
1.非空判断
2. 左右-不断递归调用自身遍历左右子树  根-访问
void postoder(bitree bt){
	bitnode *p=bt;//不要直接对树进行振作，最好定义一个新指针来振作 
	if(p!=NULL){
		postoder(p->lchild);
		postoder(p->rchild);
		cout<<p->data<<endl;
	}
} 
//非递归遍历:通过栈实现
//先序遍历
1.初始化栈
2.树与栈非空时：
树非空，访问，入栈，不断遍历左子树
树为空，栈非空，出栈，不断遍历右子树 
void preoder(bitree bt){
	initial(s);
	bitnode *q=bt,*q;
	while(q||!empty(s)){
		if(q){
			cout<<q->data<<endl;
			push(s,q);
			q=q->lchild;
		}else{
			pop(s,q);
			p=q->rchild;
		}
	}
} 
//中序遍历
1.初始化栈
2.树与栈非空时：
判断，若树非空，不断让元素入栈，遍历左子树
当树为空时，此时栈非空，出栈，不断访问元素，遍历右子树
void inorder(bitree bt){
	initial(s);
	bitnode *p=bt,*q;//q-装出栈元素 
	while(p||!empty(s)){
		if(p){
			push(s,p);
			p=p->lchild;
		}else{
			pop(s,q);
			cout<<q->data<<endl;
			p=q->rchild;
		}
	}
}
//后序遍历:
1.初始化栈
2.树与栈非空时：
判断，若树非空，不断让元素入栈，遍历左子树
当树为空时，此时栈非空，取栈顶元素，
    判断是否右子树是否为空或是否被访问，不为空且未被访问，不断遍历右子树，
         否则出栈，访问，记录访问结点出栈，不断访问元素，遍历右子树
void postoder(bitree bt){
	initial(s);
	bitnode *p=bt,*q;
	while(p||!empty(s)){
		if(p){
			push(p);
			p=p->lchild; 
		} else{
			getTop(s,p);
			if(p->rchild==NULL||p->rchild==q)
			{
				pop(s,p);
				cout<<p->data<<endl;
				q=p;
				p=NULL;
			}else p=p->rchild;
		}
	}
}  

//层次遍历：通过队列实现
typedef struct node {
	int data[maxn];
	int front,rear;
}squeue; 
void layer(bitree t){
	squeue *q;//装二叉树
	bitnode *p;
	init(q);//初始化
	enqueue(q,t);//二叉树入队 
	while(!q.empty()){
		dequeue(q,p);//出队
		cout<<p->data<<endl;
		//非空入队 
		if(p->lchild) enqueue(q,p->lchild); 
		if(p->rchild) enqueue(q,p->rchild);
	}
}