(转)树的遍历

递归与非递归转换的基础知识是能够正确理解三种树的遍历方法:前序,中序和后序,第一篇就是关于这三种遍历方法的递归和非递归算法。

如何用栈实现递归与非递归的转换(一)三种遍历树的算法

一.为什么要学习递归与非递归的转换的实现方法? 
1)并不是每一门语言都支持递归的. 
2)有助于理解递归的本质. 
3)有助于理解栈,树等数据结构.

二.三种遍历树的递归和非递归算法 
    递归与非递归的转换基于以下的原理:所有的递归程序都可以用树结构表示出来.需要说明的是,这个"原理"并没有经过严格的数学证明,只是我的一个猜想,不过在至少在我遇到的例子中是适用的.学习过树结构的人都知道,有三种方法可以遍历树:前序,中序,后序.理解这三种遍历方式的递归和非递归的表达方式是能够正确实现转换的关键之处,所以我们先来谈谈这个.需要说明的是,这里以特殊的二叉树来说明,不过大多数情况下二叉树已经够用,而且理解了二叉树的遍历,其它的树遍历方式就不难。 
            了. 
            1)前序遍历

a)递归方式: 
                  void preorder_recursive(Bitree T)      /* 先序遍历二叉树的递归算法 */ 
                        { 
                           if (T) { 
                              visit(T);          /* 访问当前结点 */ 
                              preorder_recursive(T->lchild);   /* 访问左子树 */ 
                              preorder_recursive(T->rchild);   /* 访问右子树 */ 
                           } 
                        }

b)非递归方式 
                  void preorder_nonrecursive(Bitree T)      /* 先序遍历二叉树的非递归算法 */ 
                        { 
                           initstack(S); 
                           push(S,T);             /* 根指针进栈 */ 
                           while(!stackempty(S)) { 
                              while(gettop(S,p)&&p) {      /* 向左走到尽头 */ 
                                 visit(p);      /* 每向前走一步都访问当前结点 */ 
                                 push(S,p->lchild); 
                              } 
                              pop(S,p); 
                              if(!stackempty(S)) {      /* 向右走一步 */ 
                                 pop(S,p); 
                                 push(S,p->rchild); 
                              } 
                           } 
                        }

2)中序遍历

a)递归方式 
                  void inorder_recursive(Bitree T)      /* 中序遍历二叉树的递归算法 */ 
                        { 
                           if (T) { 
                              inorder_recursive(T->lchild);   /* 访问左子树 */ 
                              visit(T);          /* 访问当前结点 */ 
                              inorder_recursive(T->rchild);   /* 访问右子树 */ 
                           } 
                        }

b)非递归方式 
                  void inorder_nonrecursive(Bitree T) 
                        { 
                           initstack(S);            /* 初始化栈 */ 
                           push(S, T);            /* 根指针入栈 */

while (!stackempty(S)) {          
                              while (gettop(S, p) && p)    /* 向左走到尽头 */ 
                                 push(S, p->lchild); 
                              pop(S, p);         /* 空指针退栈 */ 
                              if (!stackempty(S)) { 
                                 pop(S, p); 
                                 visit(p);      /* 访问当前结点 */ 
                                 push(S, p->rchild);   /* 向右走一步 */ 
                              } 
                           } 
                        }

3)后序遍历

a)递归方式 
                  void postorder_recursive(Bitree T)      /* 中序遍历二叉树的递归算法 */ 
                        { 
                           if (T) { 
                              postorder_recursive(T->lchild);   /* 访问左子树 */ 
                              postorder_recursive(T->rchild);   /* 访问右子树 */ 
                              visit(T);             /* 访问当前结点 */ 
                           } 
                        }

b)非递归方式 
                  typedef struct { 
                           BTNode* ptr; 
                           enum {0,1,2} mark; 
                        } PMType;                /* 有mark域的结点指针类型 */

void postorder_nonrecursive(BiTree T)      /* 
                  后续遍历二叉树的非递归算法 */ 
                        { 
                           PMType a; 
                           initstack(S);             /* S的元素为PMType类型 */ 
                           push (S,{T,0});          /* 根结点入栈 */ 
                           while(!stackempty(S)) { 
                              pop(S,a); 
                              switch(a.mark) 
                              { 
                              case 0: 
                                 push(S,{a.ptr,1});    /* 修改mark域 */ 
                                 if(a.ptr->lchild) 
                                    push(S,{a.ptr->lchild,0}); /* 访问左子树 */ 
                                 break; 
                              case 1: 
                                 push(S,{a.ptr,2});    /* 修改mark域 */ 
                                 if(a.ptr->rchild) 
                                    push(S,{a.ptr->rchild,0}); /* 访问右子树 */ 
                                 break; 
                              case 2: 
                                 visit(a.ptr);       /* 访问结点 */ 
                              } 
                           } 
                        }

时间: 2024-08-12 15:11:33

(转)树的遍历的相关文章

pat L2-006. 树的遍历

L2-006. 树的遍历 时间限制 400 ms 内存限制 65536 kB 代码长度限制 8000 B 判题程序 Standard 作者 陈越 给定一棵二叉树的后序遍历和中序遍历,请你输出其层序遍历的序列.这里假设键值都是互不相等的正整数. 输入格式: 输入第一行给出一个正整数N(<=30),是二叉树中结点的个数.第二行给出其后序遍历序列.第三行给出其中序遍历序列.数字间以空格分隔. 输出格式: 在一行中输出该树的层序遍历的序列.数字间以1个空格分隔,行首尾不得有多余空格. 输入样例: 7 2

一步两步学算法之树的遍历 非递归实现

递归的程序其实我觉得可读性较高  但是执行效率低下 为了做一道PAT的题 去理解了下非递归实现树的遍历 用一个栈来实现 先序遍历 先访问节点 再把节点push进栈 再访问 再push 直到next=NULL 然后pop出一个节点 也就是弹出一个节点 访问它的右边 再弹出 在访问 中序遍历 把左边节点全部push进栈 然后弹出 访问中间 再访问右边  再弹出 一直循环 后序遍历 比较难理解  要入两次栈才能访问 先左边全部入栈  栈顶是左边的元素 此书不能访问 因为右边还没入栈 下面给出先序和后序

树及遍历

节点深度:从根到节点的路径长度,d(root)=0 节点高度:从节点到树叶的最长路径的长,h(leaf)=0 树高为根高,树的深度=树的高度 树的遍历: 递归的前.中.后序还是蛮简单的: 1 //树的遍历 2 void preorder_recursive(PtrToBiNode T){ //二叉树递归先序遍历 3 if (T){ //这句不要忘记 4 printf("%d ", T->Element); 5 preorder_recursive(T->left); 6 p

leetcode404-----简单的树的遍历

Find the sum of all left leaves in a given binary tree. Example: 3 / 9 20 / 15 7 There are two left leaves in the binary tree, with values 9 and 15 respectively. Return 24. 题目给出的意思很简单.就只是单纯的树的遍历而已.意思是计算出所有左叶子节点的值的和. 我采用递归的方式表示我的遍历顺序,其实主要的是要理解题目的意思,这里

树的遍历 | Tree Traversal

树的遍历方式总体上有两种:DFS和BFS: 其中DFS包含了前序.中序和后序遍历,而BFS则为层次遍历. DFS的实现方式: (1) 递归: (2) 非递归,使用辅助栈: 递归程序 public class Recursion { public void preorderRec(TreeNode root) { if (root == null) { return; } System.out.println(root.val); // visit the node preorderRec(roo

Codeforces 29D Ant on the Tree 树的遍历 dfs序

题目链接:点击打开链接 题意: 给定n个节点的树 1为根 则此时叶子节点已经确定 最后一行给出叶子节点的顺序 目标: 遍历树并输出路径,要求遍历叶子节点时按照给定叶子节点的先后顺序访问. 思路: 给每个节点加一个优先级. 把最后一个叶子节点到父节点的路径上的点优先级改为1 把倒数第二个叶子节点到父节点的路径上的点优先级改为2 如此每个点就有一个优先级,每个访问儿子节点时先访问优先级大的即可 对于无解的判断:得到的欧拉序列不满足输入的叶子节点顺序即是无解. #include <cstdio> #

那些妖术——树的遍历

这个方法有点邪门,和大家在课堂上学的有点不一样,所以blog的名字取得有点邪乎. 一般的程序员应聘技术类的笔试都会有一道题目,那就是树的遍历(前序遍历,中序遍历和后续遍历).这里教大家玩点新鲜的, 可能和平时大家学的有点不一样.但是绝对是在考场上解决问题的神器,因为一个字快,可以帮你节省时间做其他的题目. 喜欢的小伙伴记得点赞啊.(*^__^*) 一.中序遍历 这个是最简单的,什么是中序遍历,那就是把我们的树压扁了就可以得到我们的中序遍历,所以中序遍历就是DBGEHACIJF. 什么是把树压扁了

分针网——每日分享:MySQL实现树的遍历

更多文章:www.f-z.cn 经常在一个表中有父子关系的两个字段,比如empno与manager,这种结构中需要用到树的遍历.在Oracle 中可以使用connect by简单解决问题,参见http://blog.csdn.net/wzy0623/archive/2007/06/18/1656345.aspx,但MySQL 5.1中还不支持(据说已纳入to do中),要自己写过程或函数来实现. 一.建立测试表和数据 [c-sharp] view plain copy DROP TABLE IF

如果Google面试让你用python写一个树的遍历程序

前几天忽然对python很感兴趣,学了几天也感觉它非常的简洁实用.打破了我这么长时间对java C# C 和vb的审美疲劳,让我眼前一亮."就像读英文一样简单"这句话评价python说的很合理. 我对python的好感很大部分是因为听说google很多程序用python,而且在google app engine里面和支持python.如果你去google面试或者笔试,很可能就会考到这个题:用python实现树的遍历. 自己试着写了一下,不过毕竟是菜鸟,有问题请多多指教. 运行效果如下:

(5)树的分类有哪些,树的遍历——4

树根据树结点的关系不同,可以分为有序树和无序树. 有序树指的是子树的位置自左向右有次序关系的称为有序树,顺序决定了大小,孩子的次序不能改变. 无序树指的是子树的位置自左向右无次序关系. 树的遍历针对树的类型有不同的遍历方式,其遍历方式有深度优先遍历,广度优先遍历. 深度优先遍历先访问根结点,再逐个访问子结点.(ABDECFG) 广度优先遍历就是对树中的结点逐层进行访问.  (ABCDEFG) A B      C D   E  F   G --整理自<C/C++程序员面试宝典>