目录
先序遍历
//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加进去的话，那么栈中保存的就是从根节点到这个点的路径；
而对于先序和中序，是无法通过栈来还原的。
由此也可知，先序找前驱，后序找后序，需要找父亲，需要借助栈。以这个后序非递归遍历为例，就可以知道栈可以提供遍历到的这个点的所有的祖先信息，他的父节点就是此时的栈顶。
4607
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
