目录
先序遍历
//8、二叉树的非递归遍历---先序遍历
void PreOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1;
while(p || top != -1){//当p为空但top不为空时,说明某个分支遍历结束了,而整体还没有遍历结束,因为栈里还有元素。
if(p){
Visit(p);
stack[++top] = p;//压栈,stack储存的是地址
p = p -> lchild;
}else{
p = stack[top--];//此时左子树是遍历结束的,所以栈顶元素直接出栈,找到这个位置然后接着继续访问下一个
p = p -> rchild;
}
}
}
中序遍历
//9、二叉树的非递归遍历---中序遍历
void InOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1;
while(p || top != -1){
if(p){
stack[++top] = p;//压栈
p = p -> lchild;
}else{
p = stack[top--];//此时左子树是遍历结束的,所以栈顶元素直接出栈
Visit(p);
p = p -> rchild;
}
}
}
后序遍历
//10、二叉树的非递归遍历---后序遍历
//void PostOrderN(BiTree T){
// BiTree stack[MaxSize],p = T;
// int top = -1;
// while(p || top != -1){
// if(p){
// stack[++top] = p;//压栈
// p = p -> lchild;
// }else{
// p = stack[top];//注意这边不能出栈,因为栈顶的元素还没有访问过
// p = p -> rchild;
//Visit(p);如果Visit直接在这边写的话那么是不对的,因为并不能保证此时p节点是“叶子节点”,
// }
// }
//}
/**
* 原因是p虽然是父节点的右孩子,但是他自己有可能也有左右孩子,如果有的话p就是“根节点”,那么要最后访问,而不是现在访问。
* 那么如何解决这个问题呢?问题的关键就是要搞明白p这个节点到底有没有左右孩子。
* 分析一下过程:以此树为例:1 2 99999 4 99999 99999 3 99999 99999
* 1 入栈... 然后 2 入栈
* 然后 p = p -> lchild;因为 p 没有左孩子,所以 p 为空,所以访问栈顶元素的位置,然后执行p = p -> rchild;
* 现在 p 就指向 4 了,然后 4 入栈,然后执行p = p -> lchild; 因为 4 没有左孩子,所以 p 为空,
* ①然后 p 指向栈顶元素的位置,也就是自己 4 ,
* 然后p = p -> rchild;p又变成了空,那么 p 下一步就会执行 p = stack[top];
* ②也就是 p 又指向了4!
* 那么我们就会发现当 4 自己没有左孩子的时候,p 会指向 4;
* 然而当 4 自己没有右孩子的时候,p 也会指向 4;
* 当第二种情况发生时,说明 p 是叶子节点,那么就应该 Visit(p);
* 那么现在要做的就是要区分这两种情况!
* 这两种情况有一个不同点,情况一是没有左孩子导致 p 指向 4 的,而情况二是没有右孩子导致 p 指向 4 的,
* 那么就可以自就此区分两种情况。
* 那么我们就 int 一个 tag,用来标记,如果是因为没有左孩子,就标记为 1,如果是因为没有右孩子,就标记为 2;
* 只有当 tag 为 2 的时候,才能说明这个 p 是没有左右孩子的,也就是“叶子节点”,那么就可以进行visit(p)。
* 以下为正确代码:
*/
typedef struct BiTreeNode{
int data;
struct BiTreeNode *lchild,*rchild;
int tag;
}BiTreeNode,*BiTree;
void PostOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1;
while(p || top != -1){
if(p){
stack[++top] = p;//压栈
p -> tag = 1;
p = p -> lchild;
}else{
p = stack[top];//注意这边不能出栈,因为栈顶的元素还没有访问过
if(p -> tag == 1){
p -> tag = 2;
p = p -> rchild;
}else{
Visit(p);
top--;
p = NULL;//让p为空后才能继续取栈顶新元素进行下一步
}
}
}
}
//11、二叉树的非递归遍历---后序遍历(当结构体不能改变时---也就是不能自己添加tag时)
typedef struct BiTreeNode{
int data;
struct BiTreeNode *lchild,*rchild;
}BiTreeNode,*BiTree;
void PostOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1,tag[MaxSize] = {0};
while(p || top != -1){
if(p){
stack[++top] = p;//压栈
tag[top] = 1;
p = p -> lchild;
}else{
p = stack[top];//注意这边不能出栈,因为栈顶的元素还没有访问过
if(tag[top] == 1){
tag[top] = 2;//改成 2 是因为下面要p = p -> rchild
p = p -> rchild;
}else{
Visit(p);
top--;
p = NULL;//让p为空后才能继续取栈顶新元素进行下一步
}
}
}
}
补充
当遍历到某个点时取出栈中所有元素:
以树 1 2 99999 4 99999 99999 3 99999 99999 为例
以遍历到 4 时为例
//8、二叉树的非递归遍历---先序遍历
void PreOrderN(BiTree T){
BiTree stack[MaxSize],p = T;//此处从递归转到非递归需要借助栈
int top = -1;
while(p || top != -1){//当p为空但top不为空时,说明某个分支遍历结束了,而整体还没有遍历结束,因为栈里还有元素。
if(p){
// Visit(p);
if(p -> data == 4){
for (int i = 0; i <= top; ++i) {
printf("%d ",stack[i] -> data);
}//遍历到某个点时,看一下栈里的内容
}
stack[++top] = p;//压栈,stack储存的是地址
p = p -> lchild;
}else{
p = stack[top--];//此时左子树是遍历结束的,所以栈顶元素直接出栈,找到这个位置然后接着继续访问下一个
p = p -> rchild;
}
}
}
//
//9、二叉树的非递归遍历---中序遍历
void InOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1;
while(p || top != -1){
if(p){
stack[++top] = p;//压栈
p = p -> lchild;
}else{
p = stack[top--];//此时左子树是遍历结束的,所以栈顶元素直接出栈
// Visit(p);
if(p -> data == 4){
for (int i = 0; i <= top; ++i) {
printf("%d ",stack[i] -> data);
}
}
p = p -> rchild;
}
}
}
//
//10、二叉树的非递归遍历---后序遍历
//void PostOrderN(BiTree T){
// BiTree stack[MaxSize],p = T;
// int top = -1;
// while(p || top != -1){
// if(p){
// stack[++top] = p;//压栈
// p = p -> lchild;
// }else{
// p = stack[top];//注意这边不能出栈,因为栈顶的元素还没有访问过
// p = p -> rchild;
//Visit(p);如果Visit直接在这边写的话那么是不对的,因为并不能保证此时p节点是“叶子节点”,
// }
// }
//}
/**
* 原因是p虽然是父节点的右孩子,但是他自己有可能也有左右孩子,如果有的话p就是“根节点”,那么要最后访问,而不是现在访问。
* 那么如何解决这个问题呢?问题的关键就是要搞明白p这个节点到底有没有左右孩子。
* 分析一下过程:以此树为例:1 2 99999 4 99999 99999 3 99999 99999
* 1 入栈... 然后 2 入栈
* 然后 p = p -> lchild;因为 p 没有左孩子,所以 p 为空,所以访问栈顶元素的位置,然后执行p = p -> rchild;
* 现在 p 就指向 4 了,然后 4 入栈,然后执行p = p -> lchild; 因为 4 没有左孩子,所以 p 为空,
* ①然后 p 指向栈顶元素的位置,也就是自己 4 ,
* 然后p = p -> rchild;p又变成了空,那么 p 下一步就会执行 p = stack[top];
* ②也就是 p 又指向了4!
* 那么我们就会发现当 4 自己没有左孩子的时候,p 会指向 4;
* 然而当 4 自己没有右孩子的时候,p 也会指向 4;
* 当第二种情况发生时,说明 p 是叶子节点,那么就应该 Visit(p);
* 那么现在要做的就是要区分这两种情况!
* 这两种情况有一个不同点,情况一是没有左孩子导致 p 指向 4 的,而情况二是没有右孩子导致 p 指向 4 的,
* 那么就可以自就此区分两种情况。
* 那么我们就 int 一个 tag,用来标记,如果是因为没有左孩子,就标记为 1,如果是因为没有右孩子,就标记为 2;
* 只有当 tag 为 2 的时候,才能说明这个 p 是没有左右孩子的,也就是“叶子节点”,那么就可以进行visit(p)。
* 以下为正确代码:
*/
void PostOrderN(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1;
while(p || top != -1){
if(p){
stack[++top] = p;//压栈
p -> tag = 1;
p = p -> lchild;
}else{
p = stack[top];//注意这边不能出栈,因为栈顶的元素还没有访问过
if(p -> tag == 1){
p -> tag = 2;
p = p -> rchild;
}else{
Visit(p);
top--;
p = NULL;//让p为空后才能继续取栈顶新元素进行下一步
}
}
}
}
//非递归后序遍历的另一种写法:
void PostOrderNR(BiTree T){
BiTree stack[MaxSize],p = T;
int top = -1,tag[MaxSize] = {0};
while(p || top != -1){
if(p){
stack[++top] = p;
tag[top] = 1;
p = p -> lchild;
}else{
if(tag[top] == 1){
tag[top] = 2;
p = stack[top];
p = p -> rchild;
}else{//说明是叶子节点了
p = stack[top--];
// Visit(p);
if(p -> data == 4){
for (int i = 0; i <= top ; ++i) {
printf("%d ",stack[i] -> data);
}
}
p = NULL;
}
}
}
}
int main(){
//1 2 99999 4 99999 99999 3 99999 99999
BiTree T = CreatBiTree();
PreOrderN(T);
printf("\n");
InOrderN(T);
printf("\n");
PostOrderNR(T);
printf("\n");
}
发现结果是:
当遍历的4时,后序的结果是1 2,而先序和中序的结果都是1,是因为后序是先出栈,再输出栈中元素的(可以去看一下PostOrder()的代码)。
通过结果可知:
对于后序遍历,如果把4加进去的话,那么栈中保存的就是从根节点到这个点的路径;
而对于先序和中序,是无法通过栈来还原的。
由此也可知,先序找前驱,后序找后序,需要找父亲,需要借助栈。以这个后序非递归遍历为例,就可以知道栈可以提供遍历到的这个点的所有的祖先信息,他的父节点就是此时的栈顶。