非递归后序遍历二叉树共41页文档

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

安徽电气工程职业技术学院学报
：薹６Ｍ２ａｒ０ｃｈ０
．
－Ｘ树后序遍历的递归和非递归算法
孙泽宇，赵国增，舒云星・
（洛阳工业高等专科学校计算机系，河南洛阳４１０）７０３
［要］论述了二又树后序遍历的递归算法和非递归算法，摘对递归算法中的工作栈的执行过程做了
Ｓｒｃｂｔｅｔｔｉｅ｛ｕｒ
● 收稿日期：０５—１０７０．２— ２
作者筒介：孙泽字（９７．吉林长春人．１７一）男。洛阳工业高等专科学校计算机秉麓师。研究方向：人工智能。趟目增（９７．河南越壁人。阳工业高等专科学校计算机秉麓师。研究方向：１一）男。７洛人工智能。
ｓｃｂｒ木ｅ，ｒｈ；｝ｔｔｉｅｌｔ木ｉｔｍｔｅｆｇ
后序遍历二叉树的递归算法如下：
ＴｐｄｆｓｕｔＢＴｏｅｙｅｅｒｃｉｎｄｔ
法及执行时栈的变化情况，可设计出较好的非递归化算法，本文讨论了二叉树后序遍历的递归和非递归
算法。２后序遍历二叉树的递归算法
１后序遍历左子树（）若左子树不为空）２后序遍历右子树（）若右子树不为空）３访问根结点（）若存在根结点）
二叉树数据结构如下：
二叉树是数据结构中最常见的存储形式，在算法与数据结构中经常使用。树与森林都可以转换为二叉树，而遍历算法则是二叉树最重要的操作。所谓遍历二叉树，就是遵从某种次序，遍访二叉树中的
所有结点，使得每个结点被访问一次，而且仅一次。在遍历算法中，递归算法是最普遍的，弄清了递归算

后序遍历的非递归算法(C详细)

后序遍历的非递归算法（C详细）后序遍历是二叉树遍历的一种方式，它的顺序是先遍历左子树，然后遍历右子树，最后访问根节点。

非递归实现后序遍历的算法可以使用栈来辅助实现。

首先，我们需要定义一个树节点的数据结构，例如：```cstruct TreeNodeint val;struct TreeNode* left;struct TreeNode* right;};```接下来，我们使用一个辅助栈来进行非递归后序遍历。

首先需要创建一个空栈，并将根节点入栈。

然后开始循环，直到栈为空为止。

在循环中，首先取出栈顶节点，如果该节点没有左子树且没有右子树，说明该节点是叶子节点，可以直接输出该节点的值。

如果该节点有左子树或者右子树，需要判断是否已经遍历过该节点的子节点。

为了实现后序遍历的顺序，我们需要一个标记变量来记录上次访问的节点。

如果上次访问的节点是该节点的右子树，说明该节点的左右子节点都已经访问过了，可以直接输出该节点的值。

反之，如果上次访问的节点不是该节点的右子树，将该节点重新入栈，并以右、左、中的顺序将其右子树、左子树入栈。

下面给出完整的代码实现：```c#include <stdio.h>#include <stdlib.h>struct TreeNodeint val;struct TreeNode* left;struct TreeNode* right;};void postOrderTraversal(struct TreeNode* root)if (root == NULL)return;}struct TreeNode* lastVisited = NULL; // 上次访问的节点struct TreeNode* node = root; // 当前遍历的节点struct TreeNode* stack[100]; // 栈int top = -1; // 栈顶指针while (node != NULL ， top != -1)if (node != NULL)stack[++top] = node; // 入栈node = node->left; // 访问左子树} elsestruct TreeNode* temp = stack[top]; // 取出栈顶节点if (temp->right == NULL ， temp->right == lastVisited) printf("%d ", temp->val);top--; // 出栈lastVisited = temp; // 记录上次访问的节点} elsenode = temp->right; // 访问右子树}}}struct TreeNode* createNode(int val)struct TreeNode* node = (structTreeNode*)malloc(sizeof(struct TreeNode));if (node != NULL)node->val = val;node->left = NULL;node->right = NULL;}return node;int mai//创建一个二叉树struct TreeNode* root = createNode(1); root->left = createNode(2);root->right = createNode(3);root->left->left = createNode(4);root->left->right = createNode(5); root->right->left = createNode(6); root->right->right = createNode(7);//后序遍历二叉树printf("后序遍历结果："); postOrderTraversal(root);printf("\n");return 0;```以上代码中，我们使用了一个辅助数组作为栈来实现非递归遍历。

二叉树的遍历及常用算法

⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设:L为遍历左⼦树,D为访问根结点,R为遍历右⼦树,且L必须位于R的前⾯可以得出以下三种不同的遍历次序:先序遍历操作次序为DLR,⾸先访问根结点，其次遍历根的左⼦树，最后遍历根右⼦树，对每棵⼦树同样按这三步(先根、后左、再右)进⾏中序遍历操作次序为LDR,⾸先遍历根的左⼦树，其次访问根结点，最后遍历根右⼦树，对每棵⼦树同样按这三步(先左、后根、再右)进⾏后序遍历操作次序为LRD,⾸先遍历根的左⼦树，其次遍历根的右⼦树，最后访问根结点，对每棵⼦树同样按这三步(先左、后右、最后根)进⾏层次遍历层次遍历即按照从上到下从左到右的顺序依次遍历所有节点,实现层次遍历通常需要借助⼀个队列,将接下来要遍历的结点依次加⼊队列中;遍历的应⽤“遍历”是⼆叉树各种操作的基础，可以在遍历过程中对结点进⾏各种操作，如:对于⼀棵已知⼆叉树求⼆叉树中结点的个数求⼆叉树中叶⼦结点的个数;求⼆叉树中度为1的结点个数求⼆叉树中度为2的结点个数5求⼆叉树中⾮终端结点个数交换结点左右孩⼦判定结点所在层次等等...C语⾔实现:#include <stdio.h>//⼆叉链表数据结构定义typedef struct TNode {char data;struct TNode *lchild;struct TNode *rchild;} *BinTree, BinNode;//初始化//传⼊⼀个指针令指针指向NULLvoid initiate(BinTree *tree) {*tree = NULL;}//创建树void create(BinTree *BT) {printf("输⼊当前结点值: (0则创建空节点)\n");char data;scanf(" %c", &data);//连续输⼊整形和字符时.字符变量会接受到换⾏,所以加空格if (data == 48) {*BT = NULL;return;} else {//创建根结点//注意开辟的空间⼤⼩是结构体的⼤⼩⽽不是结构体指针⼤⼩,写错了不会⽴马产⽣问题,但是后续在其中存储数据时极有可能出现内存访问异常(飙泪....) *BT = malloc(sizeof(struct TNode));//数据域赋值(*BT)->data = data;printf("输⼊节点 %c 的左孩⼦ \n", data);create(&((*BT)->lchild));//递归创建左⼦树printf("输⼊节点 %c 的右孩⼦ \n", data);create(&((*BT)->rchild));//递归创建右⼦树}}//求双亲结点(⽗结点)BinNode *Parent(BinTree tree, char x) {if (tree == NULL)return NULL;else if ((tree->lchild != NULL && tree->lchild->data == x) || (tree->rchild != NULL && tree->rchild->data == x))return tree;else{BinNode *node1 = Parent(tree->lchild, x);BinNode *node2 = Parent(tree->rchild, x);return node1 != NULL ? node1 : node2;}}//先序遍历void PreOrder(BinTree tree) {if (tree) {//输出数据printf("%c ", tree->data);//不为空则按顺序继续递归判断该节点的两个⼦节点PreOrder(tree->lchild);PreOrder(tree->rchild);}}//中序void InOrder(BinTree tree) {if (tree) {InOrder(tree->lchild);printf("%c ", tree->data);InOrder(tree->rchild);}}//后序void PostOrder(BinTree tree) {if (tree) {PostOrder(tree->lchild);PostOrder(tree->rchild);printf("%c ", tree->data);}}//销毁结点递归free所有节点void DestroyTree(BinTree *tree) {if (*tree != NULL) {printf("free %c \n", (*tree)->data);if ((*tree)->lchild) {DestroyTree(&((*tree)->lchild));}if ((*tree)->rchild) {DestroyTree(&((*tree)->rchild));}free(*tree);*tree = NULL;}}// 查找元素为X的结点使⽤的是层次遍历BinNode *FindNode(BinTree tree, char x) {if (tree == NULL) {return NULL;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];if (current->data == x) {return current;}front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}return NULL;}//层次遍历// 查找元素为X的结点使⽤的是层次遍历void LevelOrder(BinTree tree) {if (tree == NULL) {return;}//队列BinNode *nodes[1000] = {};//队列头尾位置int front = 0, real = 0;//将根节点插⼊到队列尾nodes[real] = tree;real += 1;//若队列不为空则继续while (front != real) {//取出队列头结点输出数据BinNode *current = nodes[front];printf("%2c", current->data);front++;//若当前节点还有⼦(左/右)节点则将结点加⼊队列if (current->lchild != NULL) {nodes[real] = current->lchild;real++;}if (current->rchild != NULL) {nodes[real] = current->rchild;real++;}}}//查找x的左孩⼦BinNode *Lchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->lchild;}return NULL;}//查找x的右孩⼦BinNode *Rchild(BinTree tree, char x) {BinTree node = FindNode(tree, x);if (node != NULL) {return node->rchild;}return NULL;}//求叶⼦结点数量int leafCount(BinTree *tree) {if (*tree == NULL)return 0;//若左右⼦树都为空则该节点为叶⼦,且后续不⽤接续递归了else if (!(*tree)->lchild && !(*tree)->rchild)return 1;else//若当前结点存在⼦树,则递归左右⼦树, 结果相加return leafCount(&((*tree)->lchild)) + leafCount(&((*tree)->rchild));}//求⾮叶⼦结点数量int NotLeafCount(BinTree *tree) {if (*tree == NULL)return 0;//若该结点左右⼦树均为空,则是叶⼦,且不⽤继续递归else if (!(*tree)->lchild && !(*tree)->rchild)return 0;else//若当前结点存在左右⼦树,则是⾮叶⼦结点(数量+1),在递归获取左右⼦树中的⾮叶⼦结点,结果相加 return NotLeafCount(&((*tree)->lchild)) + NotLeafCount(&((*tree)->rchild)) + 1;}//求树的⾼度(深度)int DepthCount(BinTree *tree) {if (*tree == NULL)return 0;else{//当前节点不为空则深度+1 在加上⼦树的⾼度,int lc = DepthCount(&((*tree)->lchild)) + 1;int rc = DepthCount(&((*tree)->rchild)) + 1;return lc > rc?lc:rc;// 取两⼦树深度的最⼤值 }}//删除左⼦树void RemoveLeft(BinNode *node){if (!node)return;if (node->lchild)DestroyTree(&(node->lchild));node->lchild = NULL;}//删除右⼦树void RemoveRight(BinNode *node){if (!node)return;if (node->rchild)DestroyTree(&(node->rchild));node->rchild = NULL;}int main() {BinTree tree;create(&tree);BinNode *node = Parent(tree, 'G');printf("G的⽗结点为%c\n",node->data);BinNode *node2 = Lchild(tree, 'D');printf("D的左孩⼦结点为%c\n",node2->data);BinNode *node3 = Rchild(tree, 'D');printf("D的右孩⼦结点为%c\n",node3->data);printf("先序遍历为:");PreOrder(tree);printf("\n");printf("中序遍历为:");InOrder(tree);printf("\n");printf("后序遍历为:");PostOrder(tree);printf("\n");printf("层次遍历为:");LevelOrder(tree);printf("\n");int a = leafCount(&tree);printf("叶⼦结点数为%d\n",a);int b = NotLeafCount(&tree);printf("⾮叶⼦结点数为%d\n",b);int c = DepthCount(&tree);printf("深度为%d\n",c);//查找F节点BinNode *node4 = FindNode(tree,'C');RemoveLeft(node4);printf("删除C的左孩⼦后遍历:");LevelOrder(tree);printf("\n");RemoveRight(node4);printf("删除C的右孩⼦后遍历:");LevelOrder(tree);printf("\n");//销毁树printf("销毁树 \n");DestroyTree(&tree);printf("销毁后后遍历:");LevelOrder(tree);printf("\n");printf("Hello, World!\n");return 0;}测试:测试数据为下列⼆叉树:运⾏程序复制粘贴下列内容:ABDGHECKFIJ特别感谢:iammomo。

遍历二叉树的非递归算法

问一次。这里的“ 问”的含义很广，比如修改或输出结点的信息，访删除结我们知道，二叉树有三个基本的组成部分，根，即：左子树和右予树，只要依次遍历这三个部分，能遍历整个二叉树。遍历二叉树的方式通常有就
算，所用到的数据仅为整型或实型即能满足要求，计算求精课程称作数值方点等等。
子树，再访问右子树，最后访问根结点）。由于二叉树定义的递归性，我们很容易就会想到用递归算法来遍历二叉树。设二叉树与栈的结构如下（ｃ用语言描述）：
ｔｐｄｆｓｒｃｉＮｄｙｅｅｔｕｔＢＴｏｅｆ
ｃａｄｔｈｒａａ：
据结构会对应复杂程度不同的算法，丽设计一个合适的数据结构能使算法三种，先序遍历（即：先访问根结点，再访问左子树，最后访问右子树）中序、先访问左予树，再访问根结点，后访问右子树）后序遍历（最。先访问左的复杂程度大大降低。编程人员在实践中体会到；学好～种高级语言仪能解遍历（决三成所遇到的问题，而学好数据结构却能解决八成所遇到的问题，因此，在软件设计中选择一个合适的数据结构越发显得重要。在管理科学领域中，很多问题都可以转化为树Ｔｅｒｅ型结构，而多叉树
就会不同。
）Ａｒｙｓｑｅｃ［ａ］ｒａ，ｅｕｎｅＭｘ
ｔｐｄｆｔｕｔｙｅｅｓｒｃ
树，它有４个结点。为了便于理解遍历思想，暂时为每个没有予树的结点都
ｆ
ｅｅｌｙｅｂｓ１ Ⅱ ｐ赤ａｅ：ｔｅｅｔｐ＊ｔｐ＇ｌｍｙｅｏ，

二叉树遍历（前序、中序、后序、层次、广度优先、深度优先遍历）

⼆叉树遍历（前序、中序、后序、层次、⼴度优先、深度优先遍历）⽬录转载：⼆叉树概念⼆叉树是⼀种⾮常重要的数据结构，⾮常多其他数据结构都是基于⼆叉树的基础演变⽽来的。

对于⼆叉树，有深度遍历和⼴度遍历，深度遍历有前序、中序以及后序三种遍历⽅法，⼴度遍历即我们寻常所说的层次遍历。

由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅easy理解并且代码⾮常简洁，⽽对于⼴度遍历来说，须要其他数据结构的⽀撑。

⽐⽅堆了。

所以。

对于⼀段代码来说，可读性有时候要⽐代码本⾝的效率要重要的多。

四种基本的遍历思想前序遍历：根结点 ---> 左⼦树 ---> 右⼦树中序遍历：左⼦树---> 根结点 ---> 右⼦树后序遍历：左⼦树 ---> 右⼦树 ---> 根结点层次遍历：仅仅需按层次遍历就可以⽐如。

求以下⼆叉树的各种遍历前序遍历：1 2 4 5 7 8 3 6中序遍历：4 2 7 5 8 1 3 6后序遍历：4 7 8 5 2 6 3 1层次遍历：1 2 3 4 5 6 7 8⼀、前序遍历1）依据上⽂提到的遍历思路：根结点 ---> 左⼦树 ---> 右⼦树，⾮常easy写出递归版本号：public void preOrderTraverse1(TreeNode root) {if (root != null) {System.out.print(root.val+" ");preOrderTraverse1(root.left);preOrderTraverse1(root.right);}}2）如今讨论⾮递归的版本号：依据前序遍历的顺序，优先訪问根结点。

然后在訪问左⼦树和右⼦树。

所以。

对于随意结点node。

第⼀部分即直接訪问之，之后在推断左⼦树是否为空，不为空时即反复上⾯的步骤，直到其为空。

若为空。

则须要訪问右⼦树。

注意。

在訪问过左孩⼦之后。

二叉树遍历（前中后序遍历，三种方式）

⼆叉树遍历（前中后序遍历，三种⽅式）⽬录刷题中碰到⼆叉树的遍历，就查找了⼆叉树遍历的⼏种思路，在此做个总结。

对应的LeetCode题⽬如下：，，，接下来以前序遍历来说明三种解法的思想，后⾯中序和后续直接给出代码。

⾸先定义⼆叉树的数据结构如下：//Definition for a binary tree node.struct TreeNode {int val;TreeNode *left;TreeNode *right;TreeNode(int x) : val(x), left(NULL), right(NULL) {}};前序遍历，顺序是“根-左-右”。

使⽤递归实现：递归的思想很简单就是我们每次访问根节点后就递归访问其左节点，左节点访问结束后再递归的访问右节点。

代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;helper(root,res);return res;}void helper(TreeNode *root, vector<int> &res){res.push_back(root->val);if(root->left) helper(root->left, res);if(root->right) helper(root->right, res);}};使⽤辅助栈迭代实现：算法为：先把根节点push到辅助栈中，然后循环检测栈是否为空，若不空，则取出栈顶元素，保存值到vector中，之后由于需要想访问左⼦节点，所以我们在将根节点的⼦节点⼊栈时要先经右节点⼊栈，再将左节点⼊栈，这样出栈时就会先判断左⼦节点。

代码如下：class Solution {public:vector<int> preorderTraversal(TreeNode* root) {if(root == NULL) return {};vector<int> res;stack<TreeNode*> st;st.push(root);while(!st.empty()){//将根节点出栈放⼊结果集中TreeNode *t = st.top();st.pop();res.push_back(t->val);//先⼊栈右节点，后左节点if(t->right) st.push(t->right);if(t->left) st.push(t->left);}return res;}};Morris Traversal⽅法具体的详细解释可以参考如下链接：这种解法可以实现O(N)的时间复杂度和O(1)的空间复杂度。

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

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

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

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

下面是二叉树后序遍历的非递归算法：
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)。

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

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

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

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