用递归,非递归两种方法遍历二叉树

合集下载

二叉树后序遍历的递归和非递归算法

二叉树后序遍历的递归和非递归算法

安 徽电气工 程 职 业 技术学 院学报
:薹6 M2 a r 0 c h 0

-X树后序遍历的递归和非递归算法
孙泽宇, 赵国增 , 舒云星・
( 洛阳工业高等专科学校计算机系 , 河南 洛阳 4 10 ) 703
[ 要 ] 论述了二又树后序遍历的递归算法和非递归算法, 摘 对递归算法中的工作栈 的执行过程做 了
Srcbt e t t ie { u r
● 收稿 日期 :0 5—1 0 70 . 2— 2
作者筒介: 孙泽字(97 . 吉林长春人. 17 一) 男。 洛阳工业高等专科学校计算机秉麓师。研究方向: 人工智能。 趟 目增 (97 . 河南越壁人 。 阳工业高等专科 学校计算机 秉麓师 。研究方 向: 1 一) 男。 7 洛 人工智能。
s c br 木e , r h;} t t ie lt 木 i t m te f g
后序遍历二叉树的递归算法如下 :
T p d fs u tBT o e y e e r c in d t
法及执行时栈 的变化情况 , 可设计 出较好 的非递归化算法 , 本文讨论了二叉树后序遍历的递归和非递归
算法。 2 后序遍历二叉树的递归算法
1 后序遍历左子树( ) 若左子树不为空 ) 2 后序遍历右子树( ) 若右子树不为空 ) 3 访问根结点 ( ) 若存在根结点)
二叉树数据结构如下 :
二叉树是数据结构 中最常见 的存储形式 , 在算法与数据结构中经常使用。树与森林都可以转换为 二叉树 , 而遍历算法则是二叉树最重要的操作 。所谓遍历二叉树 , 就是遵从某种次序 , 遍访二叉树 中的
所有结点, 使得每个结点被访问一次 , 而且仅一次。在遍历算法中, 递归算法是最普遍 的, 弄清 了递归算

遍历二叉树的非递归算法

遍历二叉树的非递归算法

问一次。这里的“ 问”的含义很广 ,比如修 改或输出结点的信息, 访 删除结 我们知道 , 二叉树有三个基本的组成部分, 根, 即: 左子树和右予 树, 只 要依次遍历这三个 部分, 能遍历整个二叉树 。 遍历二叉树的方式通常有 就
算, 所用到的数据仅为整型或实型即能满足要求 , 计算求精课程称作数值方 点等等。
子树, 再访问右子树 , 最后访 问根结 点) 。由于二叉树定义 的递归性, 我们很 容易就会想到用递 归算法来遍历二叉树。 设二叉树与栈 的结构如下 ( c 用 语言描述) :
t p d fs r c i N d y e e tu t B T o e f
c a d t h r a a:
据结构会对应复杂程度不 同的算法 ,丽设计一个合适 的数据 结构 能使算法 三 种, 先序遍历 ( 即: 先访 问根 结点, 再访问左子树 , 最后访问右子树) 中序 、 先访问左 予树 , 再访 问根结点, 后访 问右子树) 后序遍历 ( 最 。 先访问左 的复杂程度大大降低。 编程人员在实践 中体会到 ; 学好~种高级语言仪能解 遍历 ( 决三成所遇到的 问题, 而学好数据结构却 能解 决八成所遇 到的问题, 因此, 在软件 设计中选择一个合适的数据结构越发显得重要 。 在 管理科学领域中, 很多问题都可 以转化 为树 T e r e型结构 , 而多叉树
就会不同。
)A r ys q e c [a ] ra , eu n eM x
t p d f tu t y e e s r c
树, 它有 4 个结点。为了便于理解遍历思想 , 暂时为每个没有 予树 的结点都

e ely e b s 1 Ⅱ p 赤 a e: t e e t p *t p' lmye o ,

golang 中序遍历 递归非递归

golang 中序遍历 递归非递归

golang 中序遍历递归非递归中序遍历是二叉树遍历的一种方式,以左子树、根节点、右子树的顺序访问节点。

在Golang中,我们可以使用递归和非递归两种方式实现中序遍历。

一、递归实现中序遍历递归实现中序遍历是最简单直观的方式。

我们可以定义一个递归函数,用于按中序遍历访问树的节点。

```gopackage mainimport "fmt"type TreeNode struct {Val intLeft *TreeNodeRight *TreeNode}func inorderTraversal(root *TreeNode) {if root != nil {inorderTraversal(root.Left)fmt.Printf("%d ", root.Val)inorderTraversal(root.Right)}}func main() {// 构造一棵二叉树root := &TreeNode{Val: 1}root.Left = &TreeNode{Val: 2}root.Right = &TreeNode{Val: 3}root.Left.Left = &TreeNode{Val: 4}root.Left.Right = &TreeNode{Val: 5}fmt.Println("中序遍历结果:")inorderTraversal(root)}```以上代码中,我们先构造了一棵二叉树,然后调用`inorderTraversal`函数进行中序遍历。

递归函数首先检查根节点是否为空,如果不为空,则按照左子树、根节点、右子树的顺序递归调用自身。

二、非递归实现中序遍历非递归实现中序遍历使用栈来模拟递归的过程。

具体实现过程如下:```gopackage mainimport "fmt"type TreeNode struct {Val intLeft *TreeNodeRight *TreeNode}func inorderTraversal(root *TreeNode) { stack := []*TreeNode{}cur := rootfor len(stack) > 0 || cur != nil {for cur != nil {stack = append(stack, cur)cur = cur.Left}cur = stack[len(stack)-1]stack = stack[:len(stack)-1]fmt.Printf("%d ", cur.Val)cur = cur.Right}}func main() {// 构造一棵二叉树root := &TreeNode{Val: 1}root.Left = &TreeNode{Val: 2}root.Right = &TreeNode{Val: 3}root.Left.Left = &TreeNode{Val: 4}root.Left.Right = &TreeNode{Val: 5}fmt.Println("中序遍历结果:")inorderTraversal(root)}```以上代码中,我们定义了一个栈和一个指针`cur`,其中栈用于存储遍历过程中的节点。

c语言实现二叉树的四种遍历和求深度与叶子个数

c语言实现二叉树的四种遍历和求深度与叶子个数

c语言实现二叉树的四种遍历和求深度与叶子个数二叉树是一种常见的数据结构,它由节点组成,每个节点最多有两个子节点。

在C语言中,我们可以使用指针来实现二叉树的操作。

本文将介绍四种常见的二叉树遍历方式,以及如何求解二叉树的深度和叶子节点个数。

首先,我们需要定义一个二叉树节点的结构体,包含一个数据域和两个指针域,分别指向左子节点和右子节点。

代码如下:```cstruct TreeNode {int data;struct TreeNode* left;struct TreeNode* right;};```接下来,我们可以实现二叉树的四种遍历方式:前序遍历、中序遍历、后序遍历和层序遍历。

前序遍历是指先访问根节点,然后递归地遍历左子树和右子树。

代码如下:```cvoid preorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}printf("%d ", root->data);preorderTraversal(root->left);preorderTraversal(root->right);}```中序遍历是指先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。

代码如下:```cvoid inorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}inorderTraversal(root->left);printf("%d ", root->data);inorderTraversal(root->right);}```后序遍历是指先递归地遍历左子树和右子树,最后访问根节点。

代码如下:```cvoid postorderTraversal(struct TreeNode* root) {if (root == NULL) {return;}postorderTraversal(root->left);postorderTraversal(root->right);printf("%d ", root->data);}```层序遍历是按照树的层次逐层遍历节点。

二叉树后序遍历的非递归算法

二叉树后序遍历的非递归算法

二叉树后序遍历的非递归算法
二叉树后序遍历是指按照左子树、右子树、根节点的顺序遍历二叉树的过程。

与前序遍历和中序遍历不同,后序遍历需要考虑根节点的位置,因此需要使用栈来存储节点信息。

非递归算法一般使用栈来实现,因为后序遍历的过程中需要先遍历左子树和右子树,最后才遍历根节点,所以存储节点信息的栈需要进行一些特殊处理。

下面是二叉树后序遍历的非递归算法:
1. 创建一个空栈,并将根节点入栈。

2. 创建一个辅助变量pre表示上一个被遍历的节点。

3. 当栈不为空时,取出栈顶元素top,判断它是否为叶子节点或者它的左右子节点都被遍历过了(被遍历过的节点可以通过辅助变量pre来判断)。

4. 如果top为叶子节点或者它的左右子节点都被遍历过了,则将top出栈,并将它的值输出。

5. 如果不满足条件3,判断top的右子节点是否为pre,如果是,则说明右子树已经遍历完了,此时可以直接输出top的值,并将top出栈;如果不是,则将top的右子节点入栈。

6. 将top的左子节点入栈。

7. 将上一个被遍历的节点pre更新为top。

根据这个算法,我们可以分别对左子树和右子树进行遍历,并保证根节点最后被遍历到,从而实现二叉树的后序遍历。

这个算法的时间复杂度为O(n),空间复杂度为O(n)。

总的来说,二叉树的后序遍历是一种比较复杂的遍历方式,需要使用栈保存节点信息,并且需要特殊处理根节点的位置。

使用非递归算法实现后序遍历可以优化空间复杂度和避免栈溢出的问题。

二叉树的遍历学习心得 (4)

二叉树的遍历学习心得 (4)

二叉树的遍历学习心得 (4)二叉树是一种重要的数据结构,在计算机科学领域中被广泛应用。

对二叉树的遍历是对树进行操作和处理的重要方法之一。

二叉树遍历包括先序遍历、中序遍历和后序遍历三种,每种遍历方式都有它的特点和应用场景。

在本文中,我将结合自己的学习经历,介绍二叉树遍历的相关知识,并分享我的学习心得。

一、什么是二叉树遍历?二叉树遍历指的是按照某种次序访问二叉树的所有节点。

具体来说,遍历过程中所有节点都会被访问且只会被访问一次。

遍历是二叉树最基本的操作之一,它能够帮助我们遍历整个二叉树,并且可以实现二叉树的各种功能。

二、二叉树遍历的种类1. 先序遍历:先访问根节点,然后按照左子树到右子树的顺序依次访问所有的节点。

2. 中序遍历:按照左子树、根节点、右子树的顺序依次访问所有的节点。

3. 后序遍历:按照左子树、右子树、根节点的顺序依次访问所有的节点。

在学习二叉树遍历时,首先需要掌握各种遍历方式的定义和遍历过程。

我们需要了解如何通过递归或非递归的方式来实现二叉树的遍历。

三、学习心得在学习二叉树遍历时,我发现遍历过程中需要注意以下几点:1. 二叉树的遍历是递归算法的经典应用之一。

在递归调用时,需要注意传递和保存上一层函数中的参数和变量,以及返回值的传递和处理。

2. 在遍历时需要针对每个节点进行相应的操作,比如修改节点值、计算节点的数值、输出节点信息等等。

3. 非递归遍历时需要使用栈或队列辅助存储节点信息,在遍历时需要注意栈或队列的操作和数据结构实现。

通过实践,我逐渐掌握了二叉树遍历的基本思想,学会了如何根据需要选择不同的遍历方式。

同时,我也深刻体会到学习算法需要循序渐进、一步步地进行,并且需要强化巩固,多多实践才能真正掌握。

四、总结二叉树遍历是数据结构中的重要主题之一,是学习和掌握二叉树等数据结构算法的基础。

学习时需要理解各种遍历方式的定义和遍历过程,对递归和非递归实现进行深入的练习和掌握,通过不断地巩固和实践,最终能够掌握二叉树遍历的基本思想和实现方法。

非递归中序遍历二叉树课件

非递归中序遍历二叉树课件
由于在非递归实现中,我们使用栈来 模拟递归的过程,因此遍历后的结果 与递归实现相同。
04 非递归中序遍历 二叉树的复杂度 分析
时间复杂度
最好情况:O(n) 最坏情况:O(n)
平均情况:O(n)
空间复杂度
最好情况:O(1) 最坏情况:O(n)
平均情况:O(n)
05 非递归中序遍历 二叉树的优缺点
优点
01
02
03
空间效率高
非递归算法通常只需要常 数级别的额外空间,相比 之下,递归算法可能需要 更多的堆栈空间。
代码简洁
非递归算法的代码通常更 简洁,更易于理解和维护。
适合处理大型数据
由于非递归算法不需要大 量的堆栈空间,因此更适 合处理大型数据集。
缺点
编程技巧要求高
非递归算法需要更多的编程技巧, 特别是对于那些不熟悉这种技术 的人来说,理解和实现可能会比 较困难。
遍历过程
01
02
03
04
弹出栈顶元素,访问该 节点。
如果该节点右子节点存 在,将右子节点入栈。
如果该节点左子节点存 在,将左子节点入栈。
重复上述步骤,直到栈 为空。
遍历后的结果
01
中序遍历的顺序为:左子树 -> 根节点 -> 右子树。
02
非递归方法利用了栈的性质,实 现了从上到下、从左到右的遍历 顺序。
THANKS
感谢观看
栈为空。
实例二:复杂的二叉树
总结词:进阶应用
详细描述:对于复杂的二叉树,非递归中序遍历需要 更加细致的处理。由于树的形状可能不规则,我们需 要更加灵活地使用栈来处理节点之间的关系。在遍历 过程中,我们需要注意处理各种特殊情况,例如循环 引用、节点值相等的情况,以避免陷入无限循环或访 问错误的节点。此外,我们还需要注意优化算法的时 间复杂度和空间复杂度,以提高遍历的效率和准确性。

数据结构求二叉树的深度

数据结构求二叉树的深度

数据结构求二叉树的深度二叉树深度是指从根节点到最远叶子节点的最长路径上的节点数量。

求二叉树的深度是一个常见的问题,通常可以用递归或者非递归的方式来解决。

一、递归方法:递归是一种自上而下的解决问题的方式,在求二叉树深度时,可以使用递归来解决。

递归的思路是,对于一个根节点,它的深度等于其左子树和右子树中较大的深度加1下面是递归方法的实现,以Python语言为例:```def get_depth(root):if root is None:return 0left_depth = get_depth(root.left)right_depth = get_depth(root.right)return max(left_depth, right_depth) + 1```该递归函数的基本情况是,如果根节点为空,则深度为0;否则,递归计算左子树和右子树的深度,并取较大值,最后加1即为整个二叉树的深度。

二、非递归方法:非递归方法是一种自下而上的解决问题的方式,在求二叉树深度时,可以使用非递归的方式来解决。

非递归的思路是,使用层次遍历的方式遍历二叉树的每一层,每遍历一层,深度加1,直到遍历完所有节点。

下面是非递归方法的实现,以Python语言为例:```def get_depth(root):if root is None:return 0depth = 0queue = [root]while queue:depth += 1level_size = len(queue)for _ in range(level_size):node = queue.pop(0)if node.left:queue.append(node.left)if node.right:queue.append(node.right)return depth```该非递归函数的基本思路是,首先判断根节点是否为空,如果为空则深度为0;否则,初始化深度为0和一个队列,将根节点入队,然后进入循环,每一次循环代表一层,首先将循环变量level_size设置为队列的长度,然后将队头元素出队,并将其左右子节点入队,直到队列为空。

二叉树的递归及非递归的遍历及其应用

二叉树的递归及非递归的遍历及其应用

二叉树的递归及非递归的遍历及其应用二叉树是一种常见的数据结构,由节点和边组成,每个节点最多有两个子节点,分别称为左子节点和右子节点。

递归和非递归是两种遍历二叉树的方法,递归是通过递归函数实现,而非递归则利用栈的数据结构来实现。

二叉树的遍历是指按照一定的顺序访问二叉树中的每个节点。

常见的遍历方式有前序遍历、中序遍历和后序遍历。

1.前序遍历(Preorder Traversal):在前序遍历中,首先访问根节点,然后递归地遍历左子树和右子树。

遍历顺序为:根节点-左子树-右子树。

2.中序遍历(Inorder Traversal):在中序遍历中,首先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。

遍历顺序为:左子树-根节点-右子树。

3.后序遍历(Postorder Traversal):在后序遍历中,首先递归地遍历左子树和右子树,最后访问根节点。

遍历顺序为:左子树-右子树-根节点。

递归遍历方法的实现相对简单,但可能存在性能问题,因为递归调用会导致函数的调用和返回开销,尤其是在处理大规模二叉树时。

而非递归遍历方法则能够通过利用栈的特性,在迭代过程中模拟函数调用栈,避免了函数调用的性能开销。

非递归遍历二叉树的方法通常利用栈来实现。

遍历过程中,将节点按照遍历顺序入栈,然后访问栈顶元素,并将其出栈。

对于前序遍历和中序遍历,入栈顺序不同,而对于后序遍历,需要维护一个已访问标记来标识节点是否已访问过。

以下是非递归遍历二叉树的示例代码(以前序遍历为例):```pythonclass TreeNode:def __init__(self, val=0, left=None, right=None):self.val = valself.left = leftself.right = rightdef preorderTraversal(root): if not root:return []stack = []result = []stack.append(root)while stack:node = stack.pop()result.append(node.val)if node.right:stack.append(node.right)if node.left:stack.append(node.left)return result```在实际应用中,二叉树的遍历方法有很多应用。

判断两颗二叉树是否相似的两种方法

判断两颗二叉树是否相似的两种方法

判断两颗⼆叉树是否相似的两种⽅法名称:判断两个⼆叉树是否相似说明:此处的两个⽅法⼀个是⾮递归,⼀个是递归算法。

其实两个算法的本质思路是⼀样的就是,判断位置相同的两个结点是否同时为空或同时不为空。

只是具体的实现不⼀样。

对于层次遍历法:此处不⼩⼼⽤错了,本应该⽤队列来当作排列下⼀层元素的。

歪打正着,此处⽤栈也可以,只是判断的结点顺序不⼀样。

队列的话,是从每⼀层的左端到右端。

栈的话,是从右端到左端。

在此处都没影响。

我去,有发现⼀点,要从右到左访问⼀层的元素的话,应该⽤栈。

对于递归,看起来⽐⾮递归要简单不少。

基本的思路很简单,要注意的是,在程序需要从⼦树接收返回是否相似的信息。

这样的话,有⼀个问题,就是必须等树完全判断完才可以最终返回。

不想上⾯的,过程中发现不⼀样就可以⽴即返回了。

//层次遍历法判断两棵树是否相似bool IsSemblable1(BiTree T1,BiTree T2){stack<BiTNode* > _sta1,_sta2; //⽤来存放下⼀层元素的容器,此处栈和队列都⾏BiTNode *p1 = T1,*p2 = T2; //p1⽤来跟踪T1,p2⽤来跟踪T2while((_sta1.empty() == false || p1 != NULL) &&(_sta2.empty() == false || p2 != NULL)){if(p1 != NULL && p2 != NULL ) //如果p1和p2都不为空时{if(p1->lchild != NULL && p2->lchild != NULL) //如果p1和p2的左⼦树都不为空时{_sta1.push(p1->lchild);_sta2.push(p2->lchild);}else if( p1->lchild != NULL || p2->lchild != NULL) //如果p1的左⼦树为空,但是p2的左⼦树不为空,或者相反return false;if(p1->rchild != NULL && p2->rchild != NULL) //如果p1和p2的右⼦树都不为空时{_sta1.push(p1->rchild);_sta2.push(p2->rchild);}else if(p1->rchild != NULL || p2->rchild != NULL) //如果p1的右⼦树为空,但是p2的右⼦树不为空,或者相反return false;//访问完两棵树的当前结点后,置空让下⼀次循环弹出栈中元素(此处其实直接弹出元素也⾏)p1 = NULL;p2 = NULL;}else if(p1 != NULL || p2 != NULL) //当前节点有⼀个为空return false;else{//弹出两个树的栈顶元素p1 = _sta1.top();p2 = _sta2.top();_sta1.pop();_sta2.pop();}}return true;}//递归判断两棵树是否相似bool IsSemblable2(BiTree T1,BiTree T2){bool leftS = false,rightS = false; //⽤来接受⼦树返回的信息if(T1 == NULL && T2 == NULL) //两个结点都为空return true;else if(T1 == NULL || T2 == NULL) //有⼀个结点不为空return false;else{int leftS = IsSemblable2(T1->lchild,T2->lchild); //递归左⼦树int rightS = IsSemblable2(T1->rchild,T2->rchild); //递归右⼦树return leftS && rightS ; //返回两个⼦树的信息}}总结以上就是这篇⽂章的全部内容了,希望本⽂的内容对⼤家的学习或者⼯作具有⼀定的参考学习价值,谢谢⼤家对的⽀持。

二叉树的遍历实验报告

二叉树的遍历实验报告

二叉树的遍历实验报告一、实验目的1.了解二叉树的基本概念和性质;2.理解二叉树的遍历方式以及它们的实现方法;3.学会通过递归和非递归算法实现二叉树的遍历。

二、实验内容1.二叉树的定义在计算机科学中,二叉树是一种重要的数据结构,由节点及它们的左右儿子组成。

没有任何子节点的节点称为叶子节点,有一个子节点的节点称为一度点,有两个子节点的节点称为二度点。

二叉树的性质:1.每个节点最多有两个子节点;2.左右子节点的顺序不能颠倒,左边是父节点的左子节点,右边是父节点的右子节点;3.二叉树可以为空,也可以只有一个根节点;4.二叉树的高度是从根节点到最深叶子节点的层数;5.二叉树的深度是从最深叶子节点到根节点的层数;6.一个深度为d的二叉树最多有2^(d+1) -1个节点,其中d>=1;7.在二叉树的第i层上最多有2^(i-1)个节点,其中i>=1。

2.二叉树的遍历方式二叉树的遍历是指从根节点出发,按照一定的顺序遍历二叉树中的每个节点。

常用的二叉树遍历方式有三种:前序遍历、中序遍历和后序遍历。

前序遍历:先遍历根节点,再遍历左子树,最后遍历右子树;中序遍历:先遍历左子树,再遍历根节点,最后遍历右子树;后序遍历:先遍历左子树,再遍历右子树,最后遍历根节点。

递归算法:利用函数调用,递归实现二叉树的遍历;非递归算法:利用栈或队列,对二叉树进行遍历。

三、实验步骤1.创建二叉树数据结构并插入节点;2.实现二叉树的前序遍历、中序遍历、后序遍历递归算法;3.实现二叉树的前序遍历、中序遍历、后序遍历非递归算法;4.测试算法功能。

四、实验结果1.创建二叉树数据结构并插入节点为了测试三种遍历方式的算法实现,我们需要创建一个二叉树并插入节点,代码如下:```c++//定义二叉树节点struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};递归算法是实现二叉树遍历的最简单方法,代码如下:```c++//前序遍历非递归算法vector<int> preorderTraversal(TreeNode* root) {stack<TreeNode*> s;vector<int> res;if (!root) return res;s.push(root);while (!s.empty()) {TreeNode* tmp = s.top();s.pop();res.push_back(tmp->val);if (tmp->right) s.push(tmp->right);if (tmp->left) s.push(tmp->left);}return res;}4.测试算法功能return 0;}```测试结果如下:preorderTraversal: 4 2 1 3 6 5 7inorderTraversal: 1 2 3 4 5 6 7postorderTraversal: 1 3 2 5 7 6 4preorderTraversalNonRecursive: 4 2 1 3 6 5 7inorderTraversalNonRecursive: 1 2 3 4 5 6 7postorderTraversalNonRecursive: 1 3 2 5 7 6 4本次实验通过实现二叉树的递归和非递归遍历算法,加深了对二叉树的理解,并熟悉了遍历算法的实现方法。

二叉树的遍历教案教学设计

二叉树的遍历教案教学设计

二叉树的遍历教案教学设计教案教学设计:二叉树的遍历一、教学目标:1. 了解二叉树的遍历方式:前序遍历、中序遍历和后序遍历。

2. 能够使用递归和非递归两种方法实现二叉树的遍历。

3. 能够分析和比较不同遍历方式的时间复杂度和空间复杂度。

二、教学内容:1. 二叉树的遍历概念及分类。

2. 递归遍历算法的原理及实现。

3. 非递归遍历算法的原理及实现。

4. 比较不同遍历方式的时间复杂度和空间复杂度。

三、教学重点:1. 能够理解二叉树的遍历分类及其特点。

2. 能够使用递归和非递归两种方法实现二叉树的遍历。

四、教学难点:1. 非递归遍历算法的实现。

2. 比较不同遍历方式的时间复杂度和空间复杂度。

五、教学过程:1. 导入新知识,激发学生兴趣(5分钟)教师通过展示一棵二叉树的图片引入二叉树的遍历概念,并让学生猜测遍历的意义。

2. 介绍二叉树的遍历分类及特点(10分钟)教师介绍二叉树的遍历分类:前序遍历(根-左-右)、中序遍历(左-根-右)和后序遍历(左-右-根),并讲解每种遍历方式的特点。

3. 介绍递归遍历算法的原理及实现(15分钟)教师通过演示前序遍历的递归算法实现,介绍递归遍历的原理和递归函数的编写,让学生理解递归遍历的思路。

4. 演示递归遍历算法的应用(15分钟)教师在白板上画一棵二叉树,演示如何使用递归算法实现不同的遍历方式,并让学生跟随演示进行练习。

5. 介绍非递归遍历算法的原理及实现(15分钟)教师介绍非递归遍历算法的思路,包括使用栈数据结构进行遍历的原理及实现。

6. 演示非递归遍历算法的应用(15分钟)教师在白板上画一棵二叉树,演示如何使用非递归算法实现不同的遍历方式,并让学生跟随演示进行练习。

7. 比较不同遍历方式的时间复杂度和空间复杂度(10分钟)教师比较不同遍历方式的时间复杂度和空间复杂度,让学生了解不同的遍历方式在不同场景下的优劣。

8. 小结与作业布置(5分钟)教师对本节课进行小结,并布置作业:编写一个程序,实现二叉树的遍历,并分析所用遍历方式的时间复杂度和空间复杂度。

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结

二叉树的创建与遍历的实验总结引言二叉树是一种重要的数据结构,在计算机科学中有着广泛的应用。

了解二叉树的创建和遍历方法对于数据结构的学习和算法的理解至关重要。

本文将对二叉树的创建和遍历进行实验,并总结相应的经验和思考。

二叉树的定义在开始实验之前,我们首先需要了解二叉树的定义和基本概念。

二叉树是一种每个节点最多拥有两个子节点的树形结构。

每个节点包含一个值和指向其左右子节点的指针。

根据节点的位置,可以将二叉树分为左子树和右子树。

创建二叉树二叉树的创建可以采用多种方法,包括手动创建和通过编程实现。

在实验中,我们主要关注通过编程方式实现二叉树的创建。

1. 递归方法递归是一种常用的创建二叉树的方法。

通过递归,我们可以从根节点开始,逐层创建左子树和右子树。

具体步骤如下:1.创建一个空节点作为根节点。

2.递归地创建左子树。

3.递归地创建右子树。

递归方法的代码实现如下所示:class TreeNode:def __init__(self, value):self.value = valueself.left = Noneself.right = Nonedef create_binary_tree(values):if not values:return None# 使用队列辅助创建二叉树queue = []root = TreeNode(values[0])queue.append(root)for i in range(1, len(values)):node = TreeNode(values[i])# 当前节点的左子节点为空,则将新节点作为左子节点if not queue[0].left:queue[0].left = node# 当前节点的右子节点为空,则将新节点作为右子节点elif not queue[0].right:queue[0].right = node# 当前节点的左右子节点已经齐全,可以从队列中删除该节点queue.pop(0)# 将新节点添加到队列中,下一次循环时可以使用该节点queue.append(node)return root2. 非递归方法除了递归方法,我们还可以使用非递归方法创建二叉树。

二叉树的遍历算法

二叉树的遍历算法

二叉树的前序、后序的递归、非递归遍历算法学生姓名:贺天立指导老师:湛新霞摘要本课程设计主要解决树的前序、后序的递归、非递归遍历算法,层次序的非递归遍历算法的实现。

在课程设计中,系统开发平台为Windows 2000,程序设计设计语言采用Visual C++,程序运行平台为Windows 98/2000/XP。

用除递归算法前序,后续,中序遍历树外还通过非递归的算法遍历树。

程序通过调试运行,初步实现了设计目标,并且经过适当完善后,将可以应用在商业中解决实际问题。

关键词程序设计;C++;树的遍历;非递归遍历1 引言本课程设计主要解决树的前序、后序的递归、非递归遍历算法,层次序的非递归遍历算法的实现。

1.1课程设计的任务构造一棵树并输入数据,编写三个函数,非别是树的前序递归遍历算法、树的后序递归遍历算法、树的非递归中序遍历算法(这里的非递归以中序为例)。

在主程序中调用这三个函数进行树的遍历,观察用不同的遍历方法输出的数据的顺序和验证递归与非递归输出的数据是否一样。

1.2课程设计的性质由要求分析知,本设计主要要求解决树的前序、后序的递归、非递归遍历算法,层次序的非递归遍历算法的实现。

所以设计一个良好的前序、后序的递归、非递归遍历算法非常重要。

1.3课程设计的目的在程序设计中,可以用两种方法解决问题:一是传统的结构化程序设计方法,二是更先进的面向对象程序设计方法[1]。

利用《数据结构》课程的相关知识完成一个具有一定难度的综合设计题目,利用C语言进行程序设计。

巩固和加深对线性表、栈、队列、字符串、树、图、查找、排序等理论知识的理解;掌握现实复杂问题的分析建模和解决方法(包括问题描述、系统分析、设计建模、代码实现、结果分析等);提高利用计算机分析解决综合性实际问题的基本能力。

树的遍历分为前序、中序和后序,可以用递归算法实现树的三种遍历。

除了递归外还可以构造栈,利用出栈和入栈来实现树的前序遍历、中序遍历和后序遍历。

浅析一种二叉树非递归遍历算法的C语言实现论文.doc

浅析一种二叉树非递归遍历算法的C语言实现论文.doc

浅析一种二叉树非递归遍历算法的C语言实现论文一种二叉树非递归遍历算法的C语言实现论文导读:本论文是一篇关于一种二叉树非递归遍历算法的C语言实现的优秀论文范文,对正在写有关于递归论文的写有一定的参考和指导作用,摘要:针对二叉树的链式存储结构,分析了二叉树的各种遍历算法,探讨了递归算法的递推消除理由,提出了一种改善的非递归遍历算法并用C语言予以实现。

关键词:二叉树;遍历算法;非递归;C语言实现1009-3044(2014)01-0223-031 概述树形结构是一种非常常见的数据结构,而二叉树又是其中最重要的一种树形结构。

二叉树的遍历是指按照一定的规则和次序将二叉树中的每一个结点都访问一次,既不能重复,也不能漏掉。

一般而言,对二叉树的遍历有前序遍历、中序遍历、后序遍历和按层遍历等几种方式。

在具体的算法设计上,以上遍历方式一般采取递归算法来实现,该文将探讨采用非递归算法来实现二叉树的遍历。

2 二叉树的数据结构描述二叉树作为一种非线性结构,每个结点最多有一个双亲结点和两个子结点。

二叉树可以采用顺序存储结构和链式存储结构。

对于完全二叉树而言,采用顺序存储是非常方便并且节省空间的,但是对于大部分的非完全二叉树而言,采用顺序存储将导致空间浪费严重且结构混乱、效率低下。

因此,更多的时候,大家都更愿意用链式存储结构来表示二叉树,这样结构更加清晰,尤其是对于一种二叉树非递归遍历算法的C语言实现由写论文的好帮手.zbjy.提供,.左右子树的描述和双亲节点的描述更加方便。

该文中拟采用链式结构来表示二叉树。

用链式存储结构来表示二叉树,一个结点至少由3个域组成,即数据域、左子结点域和右子结点域(如图1所示)。

3 二叉树的遍历及递归算法实现3.1 二叉树的遍历二叉树的遍历就是一个不漏的访问树中的每个结点,同时也不能重复。

所谓“访问”,就是指对结点的数据域进行某种操作,比如说读取、删除、更新、求该节点深度等等。

对于二叉树中的任意一个部分,都可以把它看作三部分,根节点、左子树、右子树,我们用D表示访问跟结点,用L表示遍历左子树,用R表示遍历右子树,则共有以下6种遍历方式[1]。

二叉树遍历解题技巧

二叉树遍历解题技巧

二叉树遍历解题技巧
二叉树遍历是指按照一定规则,依次访问二叉树的所有节点的过程。

常见的二叉树遍历有前序遍历、中序遍历和后序遍历。

以下是一些二叉树遍历解题技巧:
1. 递归遍历:递归是最直观、最简单的遍历方法。

对于一个二叉树,可以递归地遍历其左子树和右子树。

在递归的过程中,可以对节点进行相应的处理。

例如,前序遍历可以先访问根节点,然后递归遍历左子树和右子树。

2. 迭代遍历:迭代遍历可以使用栈或队列来实现。

对于前序遍历,可以使用栈来记录遍历路径。

首先将根节点入栈,然后依次弹出栈顶节点,访问该节点,并将其右子节点和左子节点分别入栈。

中序遍历和后序遍历也可以使用类似的方法,只是访问节点的顺序会有所不同。

3. Morris遍历:Morris遍历是一种空间复杂度为O(1)的二叉树遍历方法。

它利用二叉树节点的空闲指针来存储遍历下一个节点的信息,从而避免使用额外的栈或队列。

具体步骤可以参考相关算法书籍或博客。

4. 层次遍历:层次遍历是一种逐层遍历二叉树的方法。

可以使用队列来实现。

首先将根节点入队,然后依次将队首节点出队并访问,同时将其左子节点和右子节点入队。

不断重复这个过程,直到队列为空。

层次遍历可以按照从上到下、从左到右的顺序访问二叉树的节点。

除了以上技巧,还可以根据具体问题的特点来选择合适的遍历方法。

在实际解题中,可以尝试不同的遍历方法并选择效率高、代码简洁的方法。

C++二叉树的先序,中序,后序遍历

C++二叉树的先序,中序,后序遍历

C++⼆叉树的先序,中序,后序遍历三种遍历⽅式都分为递归与⾮递归的⽅式。

三种遍历⽅式的递归思想相同。

后序遍历⾮递归⽅法分为两种,具体见代码。

构造⽅式:1 #include<iostream>2 #include<stack>3using namespace std;45 typedef struct BiTNode{6char data;7int lvisited,rvisited;//左、右孩⼦是否访问过,1表⽰已访问(此项只在后序⾮递归2算法中需要)8struct BiTNode *lchild,*rchild;9 }BiTNode,*BiTree;1011void InitBiTree(BiTree &T)//构造空⼆叉树12 {13 T=NULL;14 }15void CreateBiTree(BiTree &T)//⽣成⼆叉树16 {17char ch;18 cin>>ch;19if(ch=='0')//0代表空20 T=NULL;21else22 {23 T=(BiTree)malloc(sizeof(BiTNode));//⽣成根结点24if(!T)25 {26 cout<<"⽣成结点错误!"<<endl;27return;28 }29 T->data=ch;30 T->lvisited=0;31 T->rvisited=0;32 CreateBiTree(T->lchild);33 CreateBiTree(T->rchild);34 }35 }三种遍历⽅式代码:1void PreOrder(BiTree T)//先序递归遍历2 {3if(T!=NULL)4 {5 cout<<T->data<<"";6 PreOrder(T->lchild);7 PreOrder(T->rchild);8 }9 }10void SqlPreOrder(BiTree T)//先序⾮递归遍历11 {12 stack<BiTree> s;13 BiTree p=T;14while(p || !s.empty())15 {16if(p)17 {18 cout<<p->data<<"";19 s.push(p);20 p=p->lchild;21 }22else23 {24 p=s.top();25 p=p->rchild;26 s.pop();27 }28 }29 }30313233void InOrder(BiTree T)//中序递归遍历34 {35if(T!=NULL)36 {37 InOrder(T->lchild);38 cout<<T->data<<"";39 InOrder(T->rchild);40 }41 }42void SqInOrder(BiTree T)//中序⾮递归遍历43 {44 stack<BiTree> s;45 BiTree p=T;46while(p || !s.empty())47if(p)48 {49 s.push(p);50 p=p->lchild;51 }52else53 {54 p=s.top();55 cout<<p->data<<"";56 s.pop();57 p=p->rchild;58 }59 }60616263void PostOrder(BiTree T)//后序递归遍历64 {65if(T!=NULL)66 {67 PostOrder(T->lchild);68 PostOrder(T->rchild);69 cout<<T->data<<"";70 }71 }7273//后序⾮递归遍历1思路:因为后序⾮递归遍历⼆叉树的顺序是先访问左⼦树,再访问后⼦树,最后 74//访问根结点。

二叉树的三种遍历方式

二叉树的三种遍历方式

⼆叉树的三种遍历⽅式⼀、⼆叉树的定义⼆叉树(Binary Tree)的递归定义:⼆叉树要么为空,要么由根节点(root)、左⼦树(left subtree)和右⼦树(right subtree)组成,⽽左⼦书和右⼦树分别是⼀颗⼆叉树。

注意,在计算机中,树⼀般是"倒置"的,即根在上,叶⼦在下。

⼆、⼆叉树的层次遍历三种遍历⽅式:先序遍历、中序遍历、后序遍历(根据根节点的顺序)PreOrder(T) = T的根节点 + PreOrder(T的左⼦树) + PreOrder(T的右⼦树)InOrder(T) = InOrder(T的左⼦树) + T的根节点 + InOrder(T的右⼦树)PostOrder(T) = PostOrder(左⼦树) + PostOrder(右⼦树)其中加号表⽰字符串连接这三种遍历都是递归遍历或者说深度优先遍历 (DFS,Depth-First-Search)三、已知两种遍历⽅式,推出另⼀种遍历⽅式先序+中序---->后序后序+中序---->先序因为后序或先序可以直接得到根节点,然后只要在中序遍历中找到,就知道左右⼦树的中序和后序遍历,递归下去就可以构造出⼆叉树了。

四、样例(1) 题意:给⼀颗点带权(各权值都不相同,都是⼩于10000的整数)的⼆叉树的中序和后序遍历,找⼀个叶⼦节点使它到根的路径上的权应尽量少。

(2) 代码实现:1 #include<stdio.h>2 #include<iostream>3 #include<algorithm>4 #include<cstring>5 #include<string>6 #include<sstream>7using namespace std;89const int INF = 0x3f3f3f3f;10//因为各节点的权值各不相同且都只是整数,直接⽤权值作为节点编号11const int maxn = 10000 + 10;12int in_order[maxn], post_order[maxn], lch[maxn], rch[maxn];13int n;14int best, best_sum;1516//按⾏读取数据,并存到数组中17bool read_list(int *a)18{19string line;20if (!getline(cin, line)) return false;21 stringstream ss(line);22 n = 0;23int x;24while (ss >> x) a[n++] = x;25return n > 0;26}2728//把in_order[L1,R1]和post_order[L2,R2]建成⼀棵⼆叉树,返回树根29int build(int L1, int R1, int L2, int R2)30{31if (L2 > R2) return0; //空树32int root = post_order[R2];33int pos = L1;34while (in_order[pos] != root) pos++;35int cnt = pos - L1;36 lch[root] = build(L1, pos - 1, L2, L2 + cnt - 1);37 rch[root] = build(pos + 1, R1, L2 + cnt, R2 - 1);38return root;39}4041//从根节点出发,中序遍历,查找最⼩值42void dfs(int u, int sum)43{44 sum += u;4546//到达叶⼦节点,循环终⽌47if (!lch[u] && !rch[u])48 {49if (sum < best_sum)50 {51 best = u;52 best_sum = sum;53 }54return;55 }5657//加了个剪枝:如果当前的和⼤于当前的最⼩和,就不必从这条路继续搜58if (lch[u] && sum < best_sum) dfs(lch[u], sum);59if (rch[u] && sum < best_sum) dfs(rch[u], sum);60}6162int main()63{64while (read_list(in_order))65 {66 read_list(post_order);67 build(0, n - 1, 0, n - 1);6869 best_sum = INF;70 dfs(post_order[n - 1], 0);71 cout << best << endl;72 }73return0;74 }。

三种遍历方法

三种遍历方法

三种遍历方法一、前序遍历前序遍历是二叉树遍历的一种方法,也是最常见的遍历方式之一。

在前序遍历中,首先访问根节点,然后递归地遍历左子树,最后递归地遍历右子树。

前序遍历的应用非常广泛,例如在二叉树的构建和重建、树的深度优先搜索等问题中都会用到前序遍历。

在进行前序遍历时,可以采用递归或者非递归的方式。

1. 递归实现前序遍历:递归实现前序遍历非常简单,具体步骤如下:- 首先判断当前节点是否为空,若为空则返回;- 访问当前节点;- 递归遍历左子树;- 递归遍历右子树。

2. 非递归实现前序遍历:非递归实现前序遍历需要借助栈来实现,具体步骤如下:- 将根节点入栈;- 循环执行以下步骤,直到栈为空:- 弹出栈顶节点,并访问该节点;- 若该节点的右子节点不为空,则将右子节点入栈;- 若该节点的左子节点不为空,则将左子节点入栈。

二、中序遍历中序遍历是二叉树遍历的另一种方法,同样也是一种常用的遍历方式。

在中序遍历中,首先递归地遍历左子树,然后访问根节点,最后递归地遍历右子树。

中序遍历的应用也非常广泛,例如在二叉搜索树的操作中,中序遍历可以按照升序输出所有节点的值。

1. 递归实现中序遍历:递归实现中序遍历的步骤如下:- 首先判断当前节点是否为空,若为空则返回;- 递归遍历左子树;- 访问当前节点;- 递归遍历右子树。

2. 非递归实现中序遍历:非递归实现中序遍历同样需要借助栈来实现,具体步骤如下:- 将根节点入栈;- 循环执行以下步骤,直到栈为空:- 若当前节点不为空,则将当前节点入栈,并将当前节点指向其左子节点;- 若当前节点为空,则弹出栈顶节点,并访问该节点,然后将当前节点指向其右子节点。

三、后序遍历后序遍历是二叉树遍历的另一种方式,也是最后一种常见的遍历方式。

在后序遍历中,首先递归地遍历左子树,然后递归地遍历右子树,最后访问根节点。

后序遍历的应用也非常广泛,例如在二叉树的删除操作中,需要先删除子节点,再删除根节点。

二叉树的遍历

二叉树的遍历

T->rchild= CreatBiTree(); /*构造右子树*/ 扩展先序遍历序列
}
2021/2/21
return (T) ;}
A B Φ D Φ Φ C Φ 17Φ
T
T
T
ch=B
ch=Φ
Λ
T
T= Λ, Creat(T)
ch=A T
A
B creat(T L)
ΛB 返回
creat(T L)
creat(T R)
A
p=p->RChild;
}
2021/2/21
}
top
A
B
C
D
top
B
top
A
A
top
D
A
top
A
top
C
13
top
中序遍历二叉树的非递归算法:
A
void InOrder(BiTree T)
{ InitStack(&S); 相当于top=-1;
p=T;
B
C
while(p!=NULL | | !IsEmpty(S)) 相当于top==-1;
}
后序遍历二叉树的递归算法:
void PostOrder (BiTree T)
{ if(T!=NULL)
{ PostOrder (T->lchild);
PostOrder (T->rchild);
printf(T->data); }
2021/2/21
15
}
先序遍历二叉树的递归算法: void PreOder (BiTree T) { if(T! =NULL){ printf (T->data); PreOrder (T->lchild); PreOrder (T->rchild); } }
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

一、设计思想递归实现二叉树遍历的思想:1.要遍历二叉树首先的问题是创建二叉树。

二叉树的创建可以采用很多的方法。

例如:先序,中序,后序,还可以采用层次的方法创建二叉树。

本程序采用的是先序递归的方式创建的二叉树。

2.然后是中序,先序,后序递归遍历二叉树。

递归的思想是一直调用方法本身。

3.中序递归遍历二叉树的思想是先访问左子树,然后访问根节点,最后访问右子树。

当访问左子树或是右子树的时候,实际上调用的是函数本身。

在这里就体现了递归的思想,当函数的返回值是0的时候,则返回上一次的程序,继续执行下面的语句。

4.先序递归遍历二叉树的思想是先访问根节点,然后访问左子树,最后访问右子树。

同样如步骤3的方式相同,当访问左子树或者是右子树的收,实际上调用的是函数本身,直到返回值是0的时候,返回上一层的程序继续执行。

5.后序递归遍历二叉树的思想是先访问左子树,然后访问右子树,最后访问根节点。

同样跟步骤3的方式相同,当访问左子树或者右子树的时候实际上是调用的是方法本直到有返回值的时候才返回上一层的程序,继续执行.非递归实现二叉树遍历的思想:1.跟递归遍历二叉树的前提一样,首先应该创建一个二叉树,同样使用先序递归的方式创建二叉树。

2.然后是中序,先序,后序非递归遍历二叉树。

3.中序非递归遍历二叉树的思想是:首先是根节点压栈,当根节点的左子树不是空的时候,左子树压栈。

直到左子树为空的时候,不再压栈。

将栈顶元素出栈,访问栈顶元素,并将栈顶的右子树进栈。

当右子树的左子树不是空的时候,左子树一直进栈,直到左子树为空,则不再进栈。

重复上面的操作,直到栈空的时候。

4.先序非递归遍历二叉树的思想是:首先是根节点进栈,然后当栈不为空的时候,将栈顶元素出栈,然后访问。

同时将出栈元素的右子树进栈,左子树进栈。

重复上面的操作,直到栈为空。

5.后序非递归遍历二叉树的思想:首先是根节点进栈,当根节点的左子树不为空的时候,左子树进栈,直到左为空的时候,左子树不再进栈。

指针指向的是右子树,当右子树为空的时候,直接访问根节点。

当右子树不为空的时候,则右子树的指针进栈,当右子树的左子树不为空的时候,则左也进栈,直到左为空。

重复上面的操作,直到栈为空的时候,则遍历树完成。

二、算法流程图递归方法遍历二叉树的流程图如图1图1 递归方法遍历二叉树流程图非递归先序遍历二叉树流程图图2:非递归先序遍历二叉树流程图后序非递归遍历二叉树流程图如图3图3 后序非递归遍历二叉树流程图中序非递归遍历二叉树流程图4图4:中序非递归遍历二叉树流程三、源代码用递归的方式实现二叉树的遍历#include "stdio.h"#include "conio.h"#include <stdlib.h>/*定义二叉树*/typedef struct node{char data;struct node *lchild, *rchild;}BinTnode;typedef BinTnode * BinTree; //定义二叉树类型的指针/*先序创建二叉树*/int CreateBinTree(BinTree *T){ /*BinTree本身是一种类型,是一个指针,是指向结果体指针的类型*/ //这算是问题一//问题二是:关于栈的各种各样的操作,进栈,进的应该是指向树根的指针//问题三是:为什么要定义一个指向指针的指针char ch;*T=(BinTree)malloc(sizeof(BinTnode));if(!*T) printf("overflow");do{ch=getchar();if(ch==' '){ *T=NULL;return 0;}else{(*T)->data=ch;CreateBinTree(&((*T)->lchild));CreateBinTree(&((*T)->rchild));return 1;}}while(ch!='\0');}/*中序递归遍历*/void InorderTransverse(BinTree s){if (s){InorderTransverse(s->lchild);printf("%c", s->data);InorderTransverse(s->rchild);}}//先序递归遍历二叉树void PreOrderTranverseTree(BinTree s){if (s){printf("%c", s->data);PreOrderTranverseTree(s->lchild);PreOrderTranverseTree(s->rchild);}}//后序递归遍历二叉树void PostOrderTranverseTree(BinTree s){if (s){PreOrderTranverseTree(s->lchild);PreOrderTranverseTree(s->rchild);printf("%c", s->data);}}/*主方法*/void main(){BinTree T;printf("请按照先序的顺序输入要创建的树:\n");CreateBinTree(&T); /*中序序列创建二叉树*/printf("中序递归遍历的序列是:");InorderTransverse(T);printf("\n");//先序递归遍历printf("先序递归遍历的序列是:");PreOrderTranverseTree(T);printf("\n");//后序递归遍历printf("后序递归遍历的序列是:");PostOrderTranverseTree(T);printf("\n");用非递归的方式实现二叉树的遍历#include "stdio.h"#include "conio.h"#include <stdlib.h>/*定义二叉树*/typedef struct node{char data;struct node *lchild, *rchild;}BinTnode;typedef BinTnode * BinTree; //定义二叉树类型的指针/*栈的相关操作*/typedef struct{BinTree data[100];int top;}SeqStack;/*初始化栈*/void initStack(SeqStack *S){S->top =-1;}/*进栈*/void Push(SeqStack *S,BinTree x){ /*无论是进栈还是取栈顶元素都应该是指向树的指针*/if(S->top==100-1){printf("the stack is overflow");}else {S->top=S->top+1;S->data[S->top]=x;}}/*出栈*/int Pop(SeqStack *S,BinTree *p){if(S->top==-1){printf("the stack is underflow");return 0;}else {*p=S->data[S->top];--S->top;return 1;}}/*判断栈是不是空*/int EmptyStack(SeqStack S){if(S.top==-1) return 1;else return 0; /* 栈不空的情况*/}/*取出栈顶元素*/int GetTop(SeqStack S,BinTree *p){ //如果栈顶元素取到的是一颗子树的话,那应该返回的是。

,栈顶取到的到底应该是什么哈if(S.top==-1){printf("the stack is empty");return 0;}else {*p=S.data[S.top];return 1;}//访问结点char visit(BinTree p){return (*p).data;}/*创建二叉树*/int CreateBinTree(BinTree *T){ /*BinTree本身是一种类型,是一个指针,是指向结果体指针的类型*/ //这算是问题一//问题二是:关于栈的各种各样的操作,进栈,进的应该是指向树根的指针//问题三是:为什么要定义一个指向指针的指针char ch;*T=(BinTree)malloc(sizeof(BinTnode));if(!*T) printf("overflow");else{do{ch=getchar();if(ch!=’ ’)*T=NULL;return 0;else{(*T)->data=ch;CreateBinTree(&((*T)->lchild));CreateBinTree(&((*T)->rchild));return 1;}}while(ch!='\0');}}/*中序非递归遍历*/void InorderTransverse(BinTree T){SeqStack S;BinTree p;initStack(&S);//初始化栈printf("中序非递归序列是:");Push(&S,T); //根指针进栈T为指向二叉树的指针while(!EmptyStack(S)){ //栈不是空的情况while(GetTop(S,&p) && p)Push(&S,p->lchild); //gettop得到的结果也必须是一棵子树才行,进栈应该进的是树根的指针Pop(&S,&p);if(!EmptyStack(S)){//printf("%c",visit(p));Pop(&S,&p);printf("%c",visit(p));Push(&S,p->rchild);}}}/*先序非递归遍历*/void PreorderTransverse(BinTree T){SeqStack S;BinTree p;initStack(&S);//初始化栈Push(&S,T); //根指针进栈T为指向二叉树的指针printf("先序非递归序列是:");while(!EmptyStack(S)){Pop(&S,&p); //根节点出栈if(p!=NULL){printf("%c",visit(p));Push(&S,p->rchild);Push(&S,p->lchild);}}}/*后序非递归遍历*/void PostorderTransverse(BinTree T){SeqStack S;BinTree p,q;initStack(&S);//初始化栈p=T;printf("后序非递归序列是:");while(p ||!EmptyStack(S)){ //跳出while循环的原因是因为左子树或者右子树为空了if(p!=q){while(p!=NULL){Push(&S,p);if(p->lchild!=NULL)p=p->lchild;elsep=p->rchild;}}if(EmptyStack(S)) break;GetTop(S,&q);if(q->rchild==p){ //进栈的是右子树Pop(&S,&p);printf("%c",visit(p));p=q;}else{p=q->rchild;}}}/*主方法*/void main(){BinTree T;printf("请按照先序的顺序输入创建的树:\n");/*创建树*/CreateBinTree(&T);//中序非递归遍历InorderTransverse(T);printf("\n");//先序非递归遍历PreorderTransverse(T);printf("\n");//后序非递归遍历PostorderTransverse(T);}四、运行结果非递归方法遍历二叉树的运行结果如图5图5非递归方法遍历二叉树的结果图递归方法遍历二叉树的结果图如图6图6递归遍历二叉树的结果图五、遇到的问题及解决•首先遇到的问题是指针的问题以及指向指针的问题。

相关文档
最新文档