二叉树遍历

一、软件背景介绍树的遍历(Traversal)是指沿着某条搜索路线，依次对树中每个结点均做一次且仅做一次访问。

访问结点所做的操作依赖于具体的应用问题。

遍历是二叉树上最重要的运算之一，是二叉树上进行其它运算的基础。

从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。

因此，在任一给定结点上，可以按某种次序执行三个操作：⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。

所以二叉树的遍历也包括三种：先序遍历，中序遍历，和后序遍历。

图1：程序显示结果二、核心算法思想二叉树的存储：在内存中为数组binary分配一个大小为63（0，0，0）的存储空间，所有数组元素初始化为0，用来存放二叉树。

每三个连续的数组地址存放一个节点：第一个地址存放节点的值；第二个地址存放有无左孩子的信息，如果有则将其置为1，否则为0；第三个地址存放有无右孩子的信息，如果有则将其置为1，否则为0。

将binary的首址偏移赋给si，cx初始化为0用来计数，用回车代表输入的为空，即没有输入。

按先根存储的方式来存二叉树，首先输入一个字符，若为回车则退出程序，否则cx+3且调用函数root。

然后该结点若有左孩子，调用leftchild函数，置该结点标志即第二个地址中的0为1，该结点进栈，再存储左孩子结点，递归调用左右，若没有左孩子，看有没有右孩子，若有，则调用rightchild置该结点标志位即上第三个地址中的0为1，然后该结点进栈，再存储右孩子结点，递归调用左右，整个用cx计数，数组binary中每多一个节点，cx加3。

此存储方式正好符合先序遍历思想。

遍历二叉树的执行踪迹：三种递归遍历算法的搜索路线相同，具体线路为：从根结点出发，逆时针沿着二叉树外缘移动，对每个结点均途径三次，最后回到根结点。

二叉树的遍历有常用的三种方法，分别是：先根次序、中根次序、后根次序。

为了验证这几种遍历算法的区别，本次的实验将会实现所有的算法。

⼆叉树的遍历及常⽤算法⼆叉树的遍历及常⽤算法遍历的定义:按照某种次序访问⼆叉树上的所有结点,且每个节点仅被访问⼀次;遍历的重要性:当我们需要对⼀颗⼆叉树进⾏,插⼊,删除,查找等操作时,通常都需要先遍历⼆叉树,所有说:遍历是⼆叉树的基本操作;遍历思路:⼆叉树的数据结构是递归定义(每个节点都可能包含相同结构的⼦节点),所以遍历也可以使⽤递归,即结点不为空则继续递归调⽤每个节点都有三个域,数据与,左孩⼦指针和右孩⼦之指针,每次遍历只需要读取数据,递归左⼦树,递归右⼦树,这三个操作三种遍历次序:根据访问三个域的不同顺序,可以有多种不同的遍历次序,⽽通常对于⼦树的访问都按照从左往右的顺序;设: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。

二叉树的遍历实验报告二叉树的遍历实验报告引言：二叉树是一种常见的数据结构，它由节点和连接节点的边组成。

在实际应用中，我们经常需要对二叉树进行遍历，以便对其中的节点进行访问和操作。

本次实验旨在探索二叉树的遍历算法，并通过实验验证其正确性和效率。

一、二叉树的定义和基本操作二叉树是一种特殊的树结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。

根据节点的访问顺序，二叉树的遍历可以分为前序遍历、中序遍历和后序遍历三种方式。

前序遍历是指先访问根节点，然后按照左子树、右子树的顺序递归地进行遍历；中序遍历是指先按照左子树、根节点、右子树的顺序递归地进行遍历；后序遍历是指先按照左子树、右子树、根节点的顺序递归地进行遍历。

二、实验设计和方法为了验证二叉树的遍历算法的正确性和效率，我们设计了以下实验方案：1. 构建二叉树：我们首先构建一个具有一定规模的二叉树，以模拟实际应用中的情况。

为了方便起见，我们选择随机生成一棵二叉树，并确保其结构合理。

2. 实现遍历算法：我们根据前文所述的遍历方式，实现了相应的遍历算法。

在实现过程中，我们考虑到了递归和迭代两种方式，并分别进行了实验比较。

3. 遍历实验：我们使用不同规模的二叉树进行遍历实验，并记录遍历的结果和所花费的时间。

通过对比不同规模下不同遍历方式的结果和时间，我们可以评估遍历算法的效率和准确性。

三、实验结果和分析在实验中，我们构建了一棵具有1000个节点的二叉树，并分别使用前序、中序和后序遍历算法进行遍历。

通过实验结果的比较，我们得出以下结论：1. 遍历结果的正确性：无论是前序、中序还是后序遍历，我们都能够正确地访问到二叉树中的每个节点。

这表明我们所实现的遍历算法是正确的。

2. 遍历算法的效率：在1000个节点的二叉树中，我们发现中序遍历算法的执行时间最短，后序遍历算法的执行时间最长，前序遍历算法的执行时间居中。

这是因为中序遍历算法在访问节点时可以尽可能地减少递归次数，而后序遍历算法需要递归到最深层才能返回。

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

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

由于树的定义本⾝就是递归定义，因此採⽤递归的⽅法去实现树的三种遍历不仅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。

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

若为空。

则须要訪问右⼦树。

注意。

在訪问过左孩⼦之后。

二叉树前中后序遍历做题技巧在计算机科学中，二叉树是一种重要的数据结构，而前序、中序和后序遍历则是二叉树遍历的三种主要方式。

下面将分别对这三种遍历方式进行解析，并提供一些解题技巧。

1.理解遍历顺序前序遍历顺序是：根节点->左子树->右子树中序遍历顺序是：左子树->根节点->右子树后序遍历顺序是：左子树->右子树->根节点理解每种遍历顺序是解题的基础。

2.使用递归或迭代二叉树的遍历可以通过递归或迭代实现。

在递归中，每个节点的处理函数会调用其左右子节点的处理函数。

在迭代中，可以使用栈来模拟递归过程。

3.辨析指针指向在递归或迭代中，需要正确处理指针的指向。

在递归中，通常使用全局变量或函数参数传递指针。

在迭代中，需要使用栈或其他数据结构保存指针。

4.学会断点续传在处理大规模数据时，为了避免内存溢出，可以采用断点续传的方式。

即在遍历过程中，将中间结果保存在文件中，下次遍历时从文件中读取上一次的结果，继续遍历。

5.识别循环和终止条件在遍历二叉树时，要识别是否存在循环，并确定终止条件。

循环可以通过深度优先搜索（DFS）或广度优先搜索（BFS）避免。

终止条件通常为达到叶子节点或达到某个深度限制。

6.考虑边界情况在处理二叉树遍历问题时，要考虑边界情况。

例如，对于空二叉树，需要进行特殊处理。

又如，在处理二叉搜索树时，需要考虑节点值的最小和最大边界。

7.优化空间使用在遍历二叉树时，需要优化空间使用。

例如，可以使用in-place排序来避免额外的空间开销。

此外，可以使用懒加载技术来延迟加载子节点，从而减少内存占用。

8.验证答案正确性最后，验证答案的正确性是至关重要的。

可以通过检查输出是否符合预期、是否满足题目的限制条件等方法来验证答案的正确性。

如果可能的话，也可以使用自动化测试工具进行验证。

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

对应的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)的空间复杂度。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

二叉树的遍历（图1）（图2）二叉树的遍历运算（递归定义）(1)先序遍历：根，左子树，右子树根在先例如图1：271653894；图2：ABCKDEHFJG(2)中序遍历：左子树，根，右子树根在中例如图1：175632849；图2：BKCAHEDHFG(3)后序遍历：左子树，右子树，根根在后例如图1：153674982；图2：KCBHEJGFDA题型一：已知其中一些遍历结果，求其他遍历结果题型二：统计ｎ个不同的点可以构造多少棵不同的二叉树?Catalan数=C(n,2*n)/(n+1)题型三：中缀表达式向前缀和后缀表达式的转化每日练习注：题1已知先序和中序，二叉树是唯一的。

题2已知后序和中序，二叉树是唯一的。

题3已知先序和后序，二叉树不是唯一的。

1、已知先序：1243576，中序：2417536，请画出整棵二叉树。

2、已知后序：4526731，中序：4257631，请画出整棵二叉树。

3、已知先序：123456，后序：325641，请画所有二叉树的情况。

4、如果只知道先序ａｂｃ，画出所有可能二叉树形状，并且计算多少种？5、如果只知道中序ａｂｃ，画出所有可能二叉树形状，并且计算多少种？6、如果只知道后序ａｂｃ，画出所有可能二叉树形状，并且计算多少种？往年真题1.一颗二叉树的前序遍历序列是ABCDEFG，后序遍历序列是CBFEGDA，则根结点的左子树的结点个数可能是（）。

A．0B．2C．4D．62.表达式a*(b+c)-d的后缀表达式是：A)abcd*+-B)abc+*d-C)abc*+d-D)-+*abcd3.二叉树T，已知其先序遍历是1243576（数字为节点编号，以下同），后序遍历是4275631，则该二叉树的中根遍历是（）A．4217536B．2417536C．4217563D．24157364.二叉树T，已知其先根遍历是1243576（数字为结点编号，以下同），中根遍历是2415736，则该二叉树的后根遍历是（）A.4257631B.4275631C.7425631D.42765315.已知7个节点的二叉树的先根遍历是1245637(数字为结点的编号，以下同),后根遍历是4652731,则该二叉树的可能的中根遍历是()A.4265173B.4256137C.4231567D.42561736.已知7个节点的二叉树的先根遍历是1245637（数字为节点的编号，以下同），中根遍历是4265173，则该二叉树的后根遍历是（）A．4652731B．4652137C．4231547D．46531 727.已知6个结点的二叉树的先根遍历是123456（数字为结点的编号，以下同），后根遍历是325641，则该二叉树的可能的中根遍历是（）A.321465B.321546C.231546D.231465二叉树的性质性质1：二叉树第i层上的结点数目最多为。