数据结构:从先序和中序遍历结果恢复二叉树

合集下载

数据结构有序树转二叉树(树的遍历)

数据结构有序树转二叉树(树的遍历)

数据结构有序树转⼆叉树(树的遍历)Description计算输⼊有序树的深度和有序树转化为⼆叉树之后树的深度。

Input输⼊包含多组数据。

每组数据第⼀⾏为⼀个整数n(2<=n<=30000)代表节点的数量,接下来n-1⾏,两个整数a、b代表a是b的⽗亲结点。

Output输出当前树的深度和转化成⼆叉树之后的深度。

Sample Input51 51 35 21 4Sample Output3 4HINTAppend Code析:这个题很好说,只要遍历⼀次就能得到答案,由于要先有序树转成⼆叉树,我也没听过,我百度了⼀下怎么转,看到百度百科中有,我总结⼀下就是,左⼉⼦,右兄弟,和那个字典树有的⼀拼,也就是左结点是⼉⼦结点,⽽右结点是兄弟结点,那么我们可以⽤两个参数来记录深度,⼆叉树既然是右兄弟,那么同⼀深度的就会多⼀层,加1,这样最⼤的就是答案。

代码如下:#pragma comment(linker, "/STACK:1024000000,1024000000")#include <cstdio>#include <string>#include <cstdlib>#include <cmath>#include <iostream>#include <cstring>#include <set>#include <queue>#include <algorithm>#include <vector>#include <map>#include <cctype>#include <cmath>#include <stack>#define debug puts("+++++")//#include <tr1/unordered_map>#define freopenr freopen("in.txt", "r", stdin)#define freopenw freopen("out.txt", "w", stdout)using namespace std;//using namespace std :: tr1;typedef long long LL;typedef pair<int, int> P;const int INF = 0x3f3f3f3f;const double inf = 0x3f3f3f3f3f3f;const LL LNF = 0x3f3f3f3f3f3f;const double PI = acos(-1.0);const double eps = 1e-8;const int maxn = 3e4 + 5;const LL mod = 1e3 + 7;const int N = 1e6 + 5;const int dr[] = {-1, 0, 1, 0, 1, 1, -1, -1};const int dc[] = {0, 1, 0, -1, 1, -1, 1, -1};const char *Hex[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111", "1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"}; inline LL gcd(LL a, LL b){ return b == 0 ? a : gcd(b, a%b); }inline int gcd(int a, int b){ return b == 0 ? a : gcd(b, a%b); }inline int lcm(int a, int b){ return a * b / gcd(a, b); }int n, m;const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};inline int Min(int a, int b){ return a < b ? a : b; }inline int Max(int a, int b){ return a > b ? a : b; }inline LL Min(LL a, LL b){ return a < b ? a : b; }inline LL Max(LL a, LL b){ return a > b ? a : b; }inline bool is_in(int r, int c){return r >= 0 && r < n && c >= 0 && c < m;}vector<int> G[maxn];bool in[maxn];int ans1, ans2;void dfs(int u, int cnt1, int cnt2){ans1 = Max(ans1, cnt1);ans2 = Max(ans2, cnt2);for(int i = 0; i < G[u].size(); ++i)dfs(G[u][i], cnt1+1, cnt2+i+1);}int main(){while(scanf("%d", &n) == 1){for(int i = 0; i <= n; ++i) G[i].clear(), in[i] = 0;int u, v;for(int i = 1; i < n; ++i){scanf("%d %d", &u, &v);G[u].push_back(v);in[v] = true;}ans1 = ans2 = 0;for(int i = 1; i <= n; ++i) if(!in[i]){dfs(i, 1, 1); break;}printf("%d %d\n", ans1, ans2);}return 0;}。

数据结构实验报告——中序遍历二叉树

数据结构实验报告——中序遍历二叉树

实验报告一,实验目的:·掌握二叉树的链式存储结构;·掌握构造二叉树的方法;·加深对二叉树的中序遍历的理解;二,实验方法:·用递归调用算法中序遍历二叉树。

三,实验步骤:·通过链式存储建立一颗二叉树。

·设计一个算法实现中序遍历二叉树。

四,具体实验步骤:#include<stdio.h>#include<stdlib.h>#define LEFT 0#define RIGHT 1#define TRUE 1#define FALSE 0typedef struct _BTNODE{char c;struct _BTNODE *lchild;struct _BTNODE *rchild;}BTNODE,*PBTNODE;void PrintBTree(PBTNODE p,int depth);void ConstructBTree(PBTNODE p);void InorderTraverse(PBTNODE p);void main(){PBTNODE p;p=(PBTNODE)calloc(1,sizeof(BTNODE));printf("Input the data:");ConstructBTree(p);PrintBTree(p,0);printf("Now InorderTraverse:");InorderTraverse(p);printf("\nPress any key to continue...");getchar();}void PrintBTree(PBTNODE p,int depth){int i;if(p==NULL){return;}else{for(i=0;i<depth;i++){printf("--");}printf(">");printf("%c\n",p->c);PrintBTree(p->lchild,depth+1);PrintBTree(p->rchild,depth+1);}}void ConstructBTree(PBTNODE p){int side;char c;side=LEFT;while(TRUE){scanf("%c",&c);if(c=='\n'){//printf("EOF\n");return;}// printf("%d\n",c);switch(c){case '|':break;case')':return;case',':side=RIGHT;break;case'(':if(side==LEFT){if(p->lchild==NULL){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->lchild);}else{if(p->rchild==NULL){p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));}ConstructBTree(p->rchild);}break;default:if(side==LEFT){p->lchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->lchild->c=c;}else{p->rchild=(PBTNODE)calloc(1,sizeof(BTNODE));p->rchild->c=c;}}}}void InorderTraverse(PBTNODE p){if(p==NULL){return;}else{InorderTraverse(p->lchild);printf("[%c] ",p->c);InorderTraverse(p->rchild);}return;}五,实验过程:·输出:Input the date;·输入:1(2(3,4),5(6,7));·输出:Now InorderTraverse:【3】【2】【4】【1】【6】【5】【7】;六,上机实验体会:·体会到熟练掌握各种程序算法的重要性;·通过上机练习,充分理解了链式建立二叉树的算法;·形象的了解二叉树的结构,能够熟练的进行先序,中序,后序遍历二叉树。

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

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

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

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

由于树的定义本⾝就是递归定义,因此採⽤递归的⽅法去实现树的三种遍历不仅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.验证答案正确性最后,验证答案的正确性是至关重要的。

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

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

由二叉树的遍历序列返回二叉树

由二叉树的遍历序列返回二叉树
及 左 子 树 的 节 点数 去 看 前 序 遍 历序 列 的 相 应 部 分 , 即 前 序 序 列 的 左 子 树 的遍 历 序 列 , 再 由 中 序 序 列 的右 子 树 的 中序 遍 历 序 列 及 右 子 树 的 节 点 数 去 看 前 序 遍 历 序 列 的 相 应 部
子树; 后序遍 历的顺序为 L N, R 即先左子 树, 然后 右子树 、 根
2 3 4
Re ur ng o Bi r e r m t a e s g Se e e t ni t na y Tr e f o is Tr v r i qu nc n
Hu n a a g Xi z wo r a t o n Absr t T e p p rg n r l e t o so e u ig b n r r e b r o d rt v r a n n d r r v ra ri o d r t ae : h a e e e ai s t meh d frd c n i ay te y p e r e a e s l d i o e a e s l r e ta e s l a d e d r e r v ra . r v ra n n o d r ta e s 1
Ke wo d Bi ay T e No e y r: n r re d T aesl r v r a
Re u e d c Bi a y S r n r e n r o t g T e i
二叉树是最 为常用的数据结构 ,它的实际应 用非常广 泛。 二叉树的遍历方式有三种 , 前序遍历 、 中序遍历 、 后序遍 历 。前序遍历 的顺序为 : L 即先根 结点 , N R, 然后左 子树 、 右
维普资讯
28 1 0 年 0月 0

二叉树遍历(前中后序遍历,三种方式)

二叉树遍历(前中后序遍历,三种方式)

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

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

c语言二叉树的先序,中序,后序遍历

c语言二叉树的先序,中序,后序遍历

c语言二叉树的先序,中序,后序遍历1、先序遍历先序遍历可以想象为,一个小人从一棵二叉树根节点为起点,沿着二叉树外沿,逆时针走一圈回到根节点,路上遇到的元素顺序,就是先序遍历的结果先序遍历结果为:A B D H I E J C F K G2、中序遍历中序遍历可以看成,二叉树每个节点,垂直方向投影下来(可以理解为每个节点从最左边开始垂直掉到地上),然后从左往右数,得出的结果便是中序遍历的结果中遍历结果为:H D I B E J A F K C G3、后序遍历后序遍历就像是剪葡萄,我们要把一串葡萄剪成一颗一颗的。

还记得我上面提到先序遍历绕圈的路线么?(不记得翻上面理解)就是围着树的外围绕一圈,如果发现一剪刀就能剪下的葡萄(必须是一颗葡萄)(也就是葡萄要一个一个掉下来,不能一口气掉超过1个这样),就把它剪下来,组成的就是后序遍历了。

后序遍历中,根节点默认最后面后序遍历结果:H I D J E B K F G C A4、口诀先序遍历:先根再左再右中序遍历:先左再根再右后序遍历:先左再右再根这里的根,指的是每个分叉子树(左右子树的根节点)根节点,并不只是最开始头顶的根节点,需要灵活思考理解5、代码展示#include<stdio.h>#include<stdlib.h>typedef struct Tree{int data; // 存放数据域struct Tree *lchild; // 遍历左子树指针struct Tree *rchild; // 遍历右子树指针}Tree,*BitTree;BitTree CreateLink(){int data;int temp;BitTree T;scanf("%d",&data); // 输入数据temp=getchar(); // 吸收空格if(data == -1){ // 输入-1 代表此节点下子树不存数据,也就是不继续递归创建return NULL;}else{T = (BitTree)malloc(sizeof(Tree)); // 分配内存空间T->data = data; // 把当前输入的数据存入当前节点指针的数据域中printf("请输入%d的左子树: ",data);T->lchild = CreateLink(); // 开始递归创建左子树printf("请输入%d的右子树: ",data);T->rchild = CreateLink(); // 开始到上一级节点的右边递归创建左右子树return T; // 返回根节点}}// 先序遍历void ShowXianXu(BitTree T) // 先序遍历二叉树{if(T==NULL) //递归中遇到NULL,返回上一层节点{return;}printf("%d ",T->data);ShowXianXu(T->lchild); // 递归遍历左子树ShowXianXu(T->rchild); // 递归遍历右子树}// 中序遍历void ShowZhongXu(BitTree T) // 先序遍历二叉树{if(T==NULL) //递归中遇到NULL,返回上一层节点{return;}ShowZhongXu(T->lchild); // 递归遍历左子树printf("%d ",T->data);ShowZhongXu(T->rchild); // 递归遍历右子树}// 后序遍历void ShowHouXu(BitTree T) // 后序遍历二叉树{if(T==NULL) //递归中遇到NULL,返回上一层节点{return;}ShowHouXu(T->lchild); // 递归遍历左子树ShowHouXu(T->rchild); // 递归遍历右子树printf("%d ",T->data);}int main(){BitTree S;printf("请输入第一个节点的数据:\n");S = CreateLink(); // 接受创建二叉树完成的根节点printf("先序遍历结果: \n");ShowXianXu(S); // 先序遍历二叉树printf("\n中序遍历结果: \n");ShowZhongXu(S); // 中序遍历二叉树printf("\n后序遍历结果: \n");ShowHouXu(S); // 后序遍历二叉树return 0;}。

前序后序中序详细讲解

前序后序中序详细讲解

前序后序中序详细讲解1.引言1.1 概述在数据结构与算法中,前序、中序和后序是遍历二叉树的三种基本方式之一。

它们是一种递归和迭代算法,用于按照特定的顺序访问二叉树的所有节点。

通过遍历二叉树,我们可以获取有关树的结构和节点之间关系的重要信息。

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

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

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

它们的不同之处在于访问根节点的时机不同。

前序遍历可以帮助我们构建二叉树的镜像,查找特定节点,或者获取树的深度等信息。

中序遍历可以帮助我们按照节点的大小顺序输出树的节点,或者查找二叉搜索树中的某个节点。

后序遍历常用于删除二叉树或者释放二叉树的内存空间。

在实际应用中,前序、中序和后序遍历算法有着广泛的应用。

它们可以用于解决树相关的问题,例如在Web开发中,树结构的遍历算法可以用于生成网页导航栏或者搜索树结构中的某个节点。

在图像处理中,前序遍历可以用于图像压缩或者图像识别。

另外,前序和后序遍历算法还可以用于表达式求值和编译原理中的语法分析等领域。

综上所述,前序、中序和后序遍历算法是遍历二叉树的重要方式,它们在解决各种与树有关的问题中扮演着关键的角色。

通过深入理解和应用这些遍历算法,我们可以更好地理解和利用二叉树的结构特性,并且能够解决更加复杂的问题。

1.2文章结构文章结构是指文章中各个部分的布局和组织方式。

一个良好的文章结构可以使读者更好地理解和理解文章的内容。

本文将详细讲解前序、中序和后序三个部分的内容和应用。

首先,本文将在引言部分概述整篇文章的内容,并介绍文章的结构和目的。

接下来,正文部分将分为三个小节,分别对前序、中序和后序进行详细讲解。

在前序讲解部分,我们将定义和解释前序的意义,并介绍前序在实际应用中的场景。

通过详细的解释和实例,读者将能更好地理解前序的概念和用途。

数据结构二叉树先序中序后序考研题目

数据结构二叉树先序中序后序考研题目

数据结构二叉树先序中序后序考研题目在考研所涉及的数据结构中,二叉树以及与之相关的先序、中序和后序遍历是一个重要的考察点。

通过对二叉树的各种遍历方式的理解和掌握,可以帮助考生更好地理解树这个数据结构,提高解题的效率和正确率。

本文将针对数据结构中关于二叉树先序、中序和后序遍历的考研题目进行深入探讨,并希望能为考生提供一些帮助和启发。

一、先序、中序和后序遍历的概念在开始具体讨论考研题目之前,我们先来回顾一下先序、中序和后序遍历的概念。

在二叉树中,所谓的先序、中序和后序遍历,是指对二叉树中的节点进行遍历的顺序方式。

1. 先序遍历:先访问根节点,然后依次递归地访问左子树和右子树。

在遍历过程中,对于任一节点,先访问该节点,然后再访问其左右子树。

2. 中序遍历:先递归地访问左子树,然后访问根节点,最后再递归地访问右子树。

在遍历过程中,对于任一节点,先访问其左子树,然后访问该节点,最后再访问其右子树。

3. 后序遍历:先递归地访问左子树,然后再递归地访问右子树,最后再访问根节点。

在遍历过程中,对于任一节点,先访问其左右子树,然后再访问该节点。

二、考研题目解析1. 题目一:给出一个二叉树的中序遍历和后序遍历序列,构建该二叉树。

这是一个典型的二叉树重建题目,考查对中序和后序遍历结果的理解和利用。

解题的关键在于根据后序遍历序列确定根节点,在中序遍历序列中找到对应的根节点位置,然后再将中序遍历序列分为左右两个子树部分,分别递归构建左右子树。

考生需要对二叉树遍历的特点有清晰的认识,以及对递归构建树结构有一定的掌握。

2. 题目二:给出一个二叉树的先序遍历和中序遍历序列,构建该二叉树。

这个题目与上一个题目相似,同样是考察对二叉树重建的理解和应用。

解题思路也类似,首先根据先序遍历的结果确定根节点,在中序遍历序列中找到对应的根节点位置,然后递归构建左右子树。

需要注意的是,先序遍历序列的第一个元素即为根节点,而中序遍历序列中根节点的左边是左子树,右边是右子树。

数据结构实验三——二叉树基本操作及运算实验报告

数据结构实验三——二叉树基本操作及运算实验报告

《数据结构与数据库》实验报告实验题目二叉树的基本操作及运算一、需要分析问题描述:实现二叉树(包括二叉排序树)的建立,并实现先序、中序、后序和按层次遍历,计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目,以及二叉树常用运算。

问题分析:二叉树树型结构是一类重要的非线性数据结构,对它的熟练掌握是学习数据结构的基本要求。

由于二叉树的定义本身就是一种递归定义,所以二叉树的一些基本操作也可采用递归调用的方法。

处理本问题,我觉得应该:1、建立二叉树;2、通过递归方法来遍历(先序、中序和后序)二叉树;3、通过队列应用来实现对二叉树的层次遍历;4、借用递归方法对二叉树进行一些基本操作,如:求叶子数、树的深度宽度等;5、运用广义表对二叉树进行广义表形式的打印。

算法规定:输入形式:为了方便操作,规定二叉树的元素类型都为字符型,允许各种字符类型的输入,没有元素的结点以空格输入表示,并且本实验是以先序顺序输入的。

输出形式:通过先序、中序和后序遍历的方法对树的各字符型元素进行遍历打印,再以广义表形式进行打印。

对二叉树的一些运算结果以整型输出。

程序功能:实现对二叉树的先序、中序和后序遍历,层次遍历。

计算叶子结点数、树的深度、树的宽度,求树的非空子孙结点个数、度为2的结点数目、度为2的结点数目。

对二叉树的某个元素进行查找,对二叉树的某个结点进行删除。

测试数据:输入一:ABC□□DE□G□□F□□□(以□表示空格),查找5,删除E预测结果:先序遍历ABCDEGF中序遍历CBEGDFA后序遍历CGEFDBA层次遍历ABCDEFG广义表打印A(B(C,D(E(,G),F)))叶子数3 深度5 宽度2 非空子孙数6 度为2的数目2 度为1的数目2查找5,成功,查找的元素为E删除E后,以广义表形式打印A(B(C,D(,F)))输入二:ABD□□EH□□□CF□G□□□(以□表示空格),查找10,删除B预测结果:先序遍历ABDEHCFG中序遍历DBHEAGFC后序遍历DHEBGFCA层次遍历ABCDEFHG广义表打印A(B(D,E(H)),C(F(,G)))叶子数3 深度4 宽度3 非空子孙数7 度为2的数目2 度为1的数目3查找10,失败。

根据二叉树的后序遍历和中序遍历还原二叉树解题方法

根据二叉树的后序遍历和中序遍历还原二叉树解题方法

【题目】假设一棵二叉树的后序遍历序列为DGJHEBIFCA ,中序遍历序列为DBGEHJACIF ,则其前序遍历序列为( ) 。

A. ABCDEFGHIJB. ABDEGHJCFIC. ABDEGHJFICD. ABDEGJHCFI由题,后序遍历的最后一个值为A,说明本二叉树以节点A为根节点(当然,答案中第一个节点都是A,也证明了这一点)下面给出整个分析过程【第一步】由后序遍历的最后一个节点可知本树根节点为【A】加上中序遍历的结果,得知以【A】为根节点时,中序遍历结果被【A】分为两部分【DBGEHJ】【A】【CIF】于是作出第一幅图如下【第二步】将已经确定了的节点从后序遍历结果中分割出去即【DGJHEBIFC】---【A】此时,位于后序遍历结果中的最后一个值为【C】说明节点【C】是某棵子树的根节点又由于【第一步】中【C】处于右子树,因此得到,【C】是右子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【CIF】中来,在【CIF】中,由于【C】是根节点,所以【IF】都是这棵子树的右子树,【CIF】子树没有左子树,于是得到下图【第三步】将已经确定了的节点从后序遍历中分割出去即【DGJHEBIF】---【CA】此时,位于后序遍历结果中的最后一个值为【F】说明节点【F】是某棵子树的根节点又由于【第二步】中【F】处于右子树,因此得到,【F】是该右子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【C】【IF】中来,在【IF】中,由于【F】是根节点,所以【I】是【IF】这棵子树的左子树,于是得到下图【第四步】将已经确定了的节点从后序遍历中分割出去即【DGJHEB】---【IFCA】此时,位于后序遍历结果中的最后一个值为【B】说明节点【B】是某棵子树的根节点又由于【第一步】中【B】处于【A】的左子树,因此得到,【B】是该左子树的根节点于是回到中序遍历结果【DBGEHJ】【A】【C】【F】【I】中来,根据【B】为根节点,可以将中序遍历再次划分为【D】【B】【GEHJ】【A】【C】【F】【I】,于是得到下图【第五步】将已经确定了的节点从后序遍历中分割出去即【DGJHE】---【BIFCA】此时,位于后序遍历结果中的最后一个值为【E】说明节点【E】是某棵子树的根节点又由于【第四步】中【E】处于【B】的右子树,因此得到,【E】是该右子树的根节点于是回到中序遍历结果【D】【B】【GEHJ】【A】【C】【F】【I】中来,根据【B】为根节点,可以将中序遍历再次划分为【D】【B】【G】【E】【HJ】【A】【C】【F】【I】,于是得到下图【第六步】将已经确定了的节点从后序遍历中分割出去即【DGJH】---【EBIFCA】此时,位于后序遍历结果中的最后一个值为【H】说明节点【H】是某棵子树的根节点又由于【第五步】中【H】处于【E】的右子树,因此得到,【H】是该右子树的根节点于是回到中序遍历结果【D】【B】【G】【E】【HJ】【A】【C】【F】【I】中来,根据【H】为根节点,可以将中序遍历再次划分为【D】【B】【G】【E】【H】【J】【A】【C】【F】【I】,于是得到下图至此,整棵二叉树已经还原现在对该二叉树进行前序遍历便能得到我们想要的答案【B】。

前序遍历中序遍历复原方法

前序遍历中序遍历复原方法

前序遍历中序遍历复原方法树是一种非线性的数据结构,它的一个重要性质就是可以通过不同的遍历顺序来表达树的结构。

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

这三种遍历方式可以帮助我们了解树的结构,从而实现一些操作,比如复原树的结构。

在本文中,我们将讨论如何通过前序遍历和中序遍历的结果来复原一棵树的结构。

前序遍历、中序遍历和后序遍历是树的三种深度优先遍历方式。

它们的定义如下:-前序遍历:先访问根节点,再依次遍历左子树和右子树。

-中序遍历:先遍历左子树,再访问根节点,最后遍历右子树。

-后序遍历:先遍历左子树,再遍历右子树,最后访问根节点。

在这三种遍历方式中,前序遍历和中序遍历是最常用的。

在实际应用中,有时我们只能得到树的前序遍历和中序遍历结果,但想要还原树的结构。

那么,该如何通过前序遍历和中序遍历的结果来复原一棵树的结构呢?为了解决这个问题,我们首先需要知道前序遍历和中序遍历的性质。

在前序遍历中,第一个元素一定是根节点,在中序遍历中,根节点左边的元素都位于左子树中,根节点右边的元素都位于右子树中。

利用这些性质,我们可以进行如下步骤来复原树的结构:1.根据前序遍历的结果确定根节点。

2.在中序遍历的结果中找到根节点的位置,划分出左子树和右子树。

3.递归处理左子树和右子树,直到无法再继续递归。

下面,我们以一个具体的例子来说明如何通过前序遍历和中序遍历的结果来复原一棵树的结构。

假设我们有以下一棵树的前序遍历结果为[1,2,4,5,3,6,7],中序遍历结果为[4,2,5,1,6,3,7]。

我们需要还原这棵树的结构。

首先,根据前序遍历的结果,我们可以知道根节点是1、然后,在中序遍历的结果中找到根节点1的位置,左子树为[4,2,5],右子树为[6,3,7]。

接下来,我们递归处理左子树和右子树。

对于左子树,前序遍历结果为[2,4,5],中序遍历结果为[4,2,5]。

根据前序遍历的结果,我们可以知道左子树的根节点是2、在中序遍历的结果中找到根节点2的位置,左子树为空,右子树为[4,5]。

数据结构教程李春葆课后答案 树和二叉树

数据结构教程李春葆课后答案 树和二叉树

FindMinNode(b,min);
printf("Min=%c\n",min);
}
}
14. 假设二叉树中每个结点值为单个字符,采用二叉链存储结构存储。设计一个算法 将二叉链 b1 复制到二叉链 b2 中。
解:当 b1 为空时,置 b2 为空树。当 b1 不为空时,建立 b2 结点(b2 为根结点),置 b2->data=b1->data;递归调用 Copy(b1->lchild,b2->lchild),由 b1 的左子树建立 b2 的左 子树;递归调用 Copy(b1->rchild,b2->rchild),由 b1 的右子树建立 b2 的右子树。对应的 算法如下:
结点最少的情况是第 6 层为最下层,即 1~5 层构成一棵满二叉树,其结点总数为 25-1=31,再加上第 6 层的结点,总计 31+8=39。这样最少的结点个数为 39。
7. 已知一棵满二叉树的结点个数为 20~40 之间,此二叉树的叶子结点有多少个? 答:一棵高度为 h 的满二叉树的结点个数为 2h-1,有:20≤2h-1≤40。 则 h=5,满二叉树中叶子结点均集中在最底层,所以叶子结点个数=25-1=16 个。
num2=LeftNode(t,2*i+1);
num+=num1+num2;
}
return num;
}
else return 0;
}
else return 0;
}
12. 假设二叉树中每个结点值为单个字符,采用二叉链存储结构存储。设计一个算法 计算一棵给定二叉树 b 中的所有单分支结点个数。
解:计算一棵二叉树的所有单分支结点个数的递归模型 f(b)如下:

二叉树的先序,中序,后序遍历实验报告总结

二叉树的先序,中序,后序遍历实验报告总结

二叉树的先序,中序,后序遍历实验报告总结
二叉树的先序、中序和后序遍历是处理二叉树结构时常用的方法。

在实验中,我们可以通过实现这三种遍历算法来更好地理解二叉树的结构和特点。

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

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

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

在实验中,我们可以通过递归或非递归的方式来实现这三种遍历算法。

递归实现简单直观,但可能由于递归深度过大而导致栈溢出。

非递归实现使用栈来模拟递归的过程,可以防止栈溢出。

通过实验可以发现,先序遍历的结果是按照根节点、左子树、右子树的顺序输出,中序遍历的结果是按照左子树、根节点、右子树的顺序输出,后序遍历的结果是按照左子树、右子树、根节点的顺序输出。

不同的遍历方式可以得到不同的输出结果,对数据的处理方式也有所不同。

总之,二叉树的先序、中序和后序遍历是处理二叉树结构的重
要方法。

通过实验可以更好地理解这些遍历算法的原理和应用场景。

数据结构期中考试答案解析

数据结构期中考试答案解析

数据结构期中试卷及答案解析考试说明考试说明:考察前五章小题,难度接近真题。

满分100分,共20道选择题,每题5分。

请在60分钟内完成。

C T(n)=n3+5000nD T(n)=2nlogn-1000n参考答案:C本题考察时间复杂度,多个项相加时,只保留最高阶项由于巴啦啦能量——“常<对<幂<指<阶”,因此T(n)=logn+5000n=O(n)T(n)=n2-8000n=O(n2)T(n)=n3+5000n=O(n3)T(n)=2nlogn-1000n=O(nlogn)所以O(n3)复杂度最大,选C。

3.下列叙述中正确的是()①线性表在链式存储时,查找第 i 个元素的时间同 i 的值成正比②线性表在链式存储时,查找第 i 个元素的时间同 i 的值无关③线性表在顺序存储时,查找第 i 个元素的时间同 i 的值成正比A. 仅①B. 仅②C. 仅③D. ①②③参考答案:A线性表在链式存储时,查找第 i 个元素的时间同 i 的值成正比。

线性表在顺序存储时,查找第 i 个元素的时间同 i 的值无关4.若线性表最常用的操作是存取第i个元素及其前驱和后继元素的值,为节省时间应采用的存储方式()。

A. 单链表B. 双向链表C. 单循环链表D. 顺序表参考答案:D注意到,题目要求存取第i个元素及其前驱和后继,ABC三个选项找到第i个元素的时间复杂度均为O(n),而D选项对于这3个位置的存取的时间复杂度均为O(1),故选D。

5.静态链表中next域表示的是()A 下一个元素的地址B 下一个元素的值C 当前元素的值D 下一个元素在数组中的位置参考答案:D静态链表一般保存在数组中,它和链表最大的区别是静态链表占用一段固定的区间,所以next域只需要表示下一个元素在数组中的下标即可而不是表示下一个元素的地址,选D。

6.对于不带头结点的链栈L(next域表示该结点下一个元素),top指针指向栈顶元素(栈顶在链头方向),则x结点进栈操作为A top->next=x;top=x;B top=x;top-next=x;C top=x;x->next=top;D x->next=top;top=x;参考答案:D本题考察链栈的操作x入栈之后x下一个元素为原来的top,所以先把x->next=top,然后更新top,栈顶元素指向x。

前序序列和后续序列确定二叉树

前序序列和后续序列确定二叉树

前序序列和后续序列确定⼆叉树⼆叉树:已知前序与后序建树那么我们换⼀种思考⽅式,我们先来看看先序与后序序列的排布规律。

以下⾯这棵树来举例:其先序序列为: 1 2 3 4 6 7 5后序序列为:2 6 7 4 5 3 1⾸先我们要知道:先序序列遍历顺序是:根结点-左⼦树-右⼦树后序序列遍历顺序是:左⼦树-右⼦树-根结点很明显,我们可以看出结点在先、后序列中的排布有以下这些特征:【1】、在先序序列中,根结点在⼦树中的结点前⾯,在后序序列中,根结点在⼦树中的结点后⾯。

【2】、以任⼀节点为根结点时,其⼦树在先序后序序列中排布都是先左⼦树后右⼦树,⽽根结点排在最后。

那么,反过来思考,已知这个先序与后序序列所确定的树是唯⼀的吗?进⼀步推⼴:怎么通过先序与后序序列判断是否存在唯⼀的树呢?现在,我们来⼀步步分析已知先序与后序的建树过程:①、根据特征【1】可知:根结点为先序序列第⼀个节点以及后序序列最后⼀个结点,因此根结点为1。

②、先序序列中第⼆个结点为2,其在后序序列中的位置是第⼀个,那么根据特征【2】我们可以知道结点2是没有⼦树的,⽽且结点2要么在根结点的左⼦树,要么在右⼦树。

假设结点2在右⼦树,那么由特征【2】可知根结点1没有左⼦树,⽽且先序序列中结点2后⾯的结点全部为结点2的⼦树上的结点。

再看后序序列,由特征【2】可知,结点2后⾯的结点不可能是其⼦树上的结点。

因此,假设显然与已知⽭盾。

这样,我们⼜知道结点2是结点1的左孩⼦,且结点2没有⼦结点。

③、先序序列第三个位置上的结点为3,该结点在后序序列中排倒数第⼆个。

由②可知,结点3必然是根结点1的右孩⼦。

④、先序序列第四个位置上的结点为4,该结点在后序序列中排第四个。

因为结点4在先序序列中排在结点3后⾯,⼜因为结点3是根结点1的右孩⼦,所以结点4只可能在结点3的⼦树上。

结点3的⼦树可能出现的情况是:只有左⼦树,只有右⼦树,左右⼦树都有。

因为在后序序列中,结点4左边是结点6、7,右边是结点5。

数据结构 实验四 二叉树的基本操作

数据结构 实验四 二叉树的基本操作

实验四二叉树的基本操作一、实验目的:(1)掌握二叉树的定义和存储表示,学会建立一棵特定二叉树的方法;(2)掌握二叉树的遍历算法(先序、中序、后序遍历算法)的思想;(3)掌握二叉树和叶子数、深度之间的关系及联系。

二、实验内容:构造二叉树,再实现二叉树的先序、中序、后序遍历,最后统计二叉树的叶子数和深度。

三、实验步骤:(一) 需求分析1. 二叉树的建立首先要建立一个二叉链表的结构体,包含根节点和左右子树。

因为树的每一个左右子树又是一颗二叉树,所以用递归的方法来建立其左右子树。

二叉树的遍历是一种把二叉树的每一个节点访问并输出的过程,遍历时根结点与左右孩子的输出顺序构成了不同的遍历方法,这个过程需要按照不同的遍历的方法,先输出根结点还是先输出左右孩子,可以用选择语句来实现。

2.程序的执行命令为:1)构造结点类型,然后创建二叉树。

2)根据提示,从键盘输入各个结点。

3)通过选择一种方式(先序、中序或者后序)遍历。

4)输出结果,结束。

(二)概要设计1.二叉树的二叉链表结点存储类型定义typedef struct Node {DataType data;struct Node *LChild;struct Node *RChild;}BitNode,*BitTree;2.建立如下图所示二叉树:3.本程序包含六个模块1) 主程序模块2)先序遍历模块3)中序遍历模块4)后序遍历模块5)叶子数模块6)深度模块四、测试结果1. 进入演示程序后的显示主界面:请输入二叉树中的元素;先序、中序、后序遍历和叶子数、深度分别输出结果。

2.测试结果以扩展先序遍历序列输入,其中#代表空子树:ABC##DE#G##F### 先序遍历序列为:ABCDEGF中序遍历序列为:CBEGDFA后序遍历序列为:CGEFDBA此二叉树的叶子数为:3此二叉树的深度为:53.程序运行结果截图:五、源代码#include#include//节点声明,数据域、左孩子指针、右孩子指针typedef struct BiTNode{char data;struct BiTNode *lchild,*rchild;}BiTNode,*BiTree;//先序建立二叉树BiTree CreateBiTree(){char ch;BiTree T;scanf("%c",&ch);if(ch=='#')T=NULL;else{T = (BiTree)malloc(sizeof(BiTNode));T->data = ch;T->lchild = CreateBiTree();T->rchild = CreateBiTree();}return T;//返回根节点}//先序遍历void PreOrderTraverse(BiTree T){ if(T){printf("%c",T->data);PreOrderTraverse(T->lchild);PreOrderTraverse(T->rchild);}}//中序遍历void InOrderTraverse(BiTree T){ if(T){InOrderTraverse(T->lchild);printf("%c",T->data);InOrderTraverse(T->rchild);}}//后序遍历void PostOrderTraverse(BiTree T){ if(T){PostOrderTraverse(T->lchild);PostOrderTraverse(T->rchild);printf("%c",T->data);}}//求二叉树的深度int Depth(BiTree T){int dep=0,depl,depr;if(!T) dep=0;else{depl=Depth(T->lchild);depr=Depth(T->rchild);dep=1+(depl>depr?depl:depr);}return dep;}//计算叶子节点数int leef(BiTree T){if(!T)return 0;elseif(T->lchild ==NULL&&T->rchild ==NULL)return 1;elsereturn leef(T->lchild) +leef(T->rchild );}//主函数void main(){BiTree T;printf("请按先序输入序列(其中的“#”表示空)\n\n");T = CreateBiTree();//建立二叉树printf("\n先序遍历结果为:");PreOrderTraverse(T);//先序遍历输出printf("\n\n中序遍历结果为:");InOrderTraverse(T);//中序遍历输出printf("\n\n后序遍历结果为:");PostOrderTraverse(T);//后序遍历输出printf("\n\n二叉树深度为:%d\n",Depth(T)); Depth(T);//计算二叉树深printf("\n叶子节点数为:%d\n\n",leef(T)); leef(T);//计算叶子节点数}。

数据结构——已知先序中序求后序,已知中序后序求先序

数据结构——已知先序中序求后序,已知中序后序求先序

数据结构——已知先序中序求后序,已知中序后序求先序 总结下⼆叉树的已知两种遍历⽅式求第三种遍历顺序的⽅法,已知先序和中序遍历或者后序与中序遍历后⼆叉树是唯⼀确定的,下⾯介绍怎么求出第三种遍历顺序。

先序遍历顺序为:根结点——左⼦结点——右⼦结点,中序遍历为:左⼦结点——根结点——右⼦结点,我们注意到,先序遍历的第⼀个元素就是⼆叉树根结点,我们在中序遍历中以该元素分为左右两部分,则左边为左⼦树,右边为右⼦树,递归即可还原⼆叉树,这个过程中可直接输出后序遍历的顺序。

同理,可以⽤后序与中序还原出先序遍历的顺序。

代码及测试数据如下:1 #include <iostream>2 #include <cstdio>3 #include <cstring>4 #include <algorithm>5 #include <malloc.h>6 #include <string>7 #include <vector>8 #include <stack>9 #include <queue>10 #include <set>11 #include <map>1213#define FRER() freopen("in.txt", "r", stdin);1415using namespace std;1617//函数状态码定义18#define TRUE 119#define FALSE 020#define OK 121#define ERROR 022#define INFEASIBLE -123#define OVERFLOW -22425 typedef char TElemType;26 typedef int Status;2728 typedef struct BiNode {29 TElemType data;30struct BiNode *lchild, *rchild;31 }BiNode, *BiTree;3233 BiTree BinaryTreeFormorderings(char *, char *, int);34 BiTree BinaryTreePostorderings(char *, char *, int);3536/*37ABDECFG38DBEAFCG39DEBFGCA40*/4142int main()43 {44 FRER()45int n;46char str[100], ptr[100];47 cin >> n >> str >> ptr;48 BinaryTreePostorderings(str, ptr, n);49return0;50 }5152 BiTree BinaryTreeFormorderings(char *pre, char *in, int len) {53if(len <= 0)54return NULL;55 BiNode *node = new BiNode;56 node->data = *pre;57int idx = 0;58while(idx < len) {59if(*(in + idx) == *pre)60break;61 ++idx;62 }63 node->lchild = BinaryTreeFormorderings(pre + 1, in, idx);64 node->rchild = BinaryTreeFormorderings(pre + idx + 1, in + idx + 1, len - (idx + 1));65 cout << node->data << '';66return node;67 }6869 BiTree BinaryTreePostorderings(char *in, char *post, int len) {70if(len == 0)71return NULL;72 BiNode *node = new BiNode;73 node->data = *(post + len - 1);74 cout << node->data << '';75int idx = 0;76while(idx < len) {77if(*(in + idx) == *(post + len - 1))78break;79 ++idx;80 }81 node->lchild = BinaryTreePostorderings(in, post, idx);82 node->rchild = BinaryTreePostorderings(in + idx + 1, post + idx, len - (idx + 1)); 83return node;84 }。

前序遍历和中序遍历唯一确定一颗二叉树

前序遍历和中序遍历唯一确定一颗二叉树

前序遍历和中序遍历唯⼀确定⼀颗⼆叉树---恢复内容开始---问题描述如果给出了遍历⼆叉树的前序序列和中序序列,则可以构造出唯⼀的⼀颗⼆叉树。

基本要求已知⼀棵⼆叉树的前序序列和中序序列,试设计完成下列任务的⼀个算法:(1).构造⼀颗⼆叉树(2).证明构造正确(即分拨⼉以前序和中序遍历该树,将得到的结果与给出的序列进⾏⽐较)(3).对该⼆叉树进⾏后序遍历,输出后序遍历序列(4).⽤凹⼊法输出该⼆叉树测试数据前序序列为ABDEGCFHIJ,中序序列为DBGEAHFIJC代码思路1.确定树的根节点,树根是当前树中所有元素在前序遍历中最先出现的元素。

2.求解树的⼦树,找出根节点在中序遍历中的位置,根左边的所有元素就是左⼦树,根右边的所有元素就是右⼦树。

若根节点左边或右边为空,则该⽅向⼦树为空;若根节点左边和右边都为空,则根节点已经为叶⼦节点。

3.递归求解树,将左⼦树和右⼦树分别看成⼀棵⼆叉树,重复1、2、3步,直到所有的节点完成定位。

源代码/*1.确定树的根节点,树根是当前树中所有元素在前序遍历中最先出现的元素。

2.求解树的⼦树,找出根节点在中序遍历中的位置,根左边的所有元素就是左⼦树,根右边的所有元素就是右⼦树。

若根节点左边或右边为空,则该⽅向⼦树为空;若根节点左边和右边都为空,则根节点已经为叶⼦节点。

3.递归求解树,将左⼦树和右⼦树分别看成⼀棵⼆叉树,重复1、2、3步,直到所有的节点完成定位。

*/#include<iostream>#include<algorithm>#include<string>#include<cstring>using namespace std;const int maxint = 10000;char ch1[maxint], ch2[maxint]; //前序序列,中序序列int length; //⼆叉树结点的个数struct tree {char name;struct tree *leftchild;struct tree *rightchild;};//访问函数void vis(char name) {cout << name;}//初始化void init(struct tree **root){*root = (struct tree *)malloc(sizeof(struct tree));(*root)->leftchild = NULL;(*root)->rightchild = NULL;}//创建左⼦树struct tree *build_ltree(struct tree *h,char name) {struct tree *p, *t;if (h == NULL) return NULL;t = h->leftchild;p= (struct tree*)malloc(sizeof(struct tree));p->name = name;p->leftchild = t;p->rightchild = NULL;h->leftchild = p;return h->leftchild;}//创建右⼦树struct tree *build_rtree(struct tree *h, char name) {struct tree *p, *t;if (h == NULL) return NULL;t = h->rightchild;p = (struct tree*)malloc(sizeof(struct tree));p->name = name;p->leftchild = NULL;p->rightchild = t;h->rightchild = p;return h->rightchild;}void print_tree(struct tree *t, int n) {if (t == NULL) return;print_tree(t->rightchild, n + 1);for (int i = 0; i < n - 1; i++) cout << "";if (n > 0) {cout<<"***";cout << t->name << endl;}print_tree(t->leftchild, n + 1);}//前序遍历void preorder(struct tree *t, void vis(char name)) {if (t != NULL) {vis(t->name);preorder(t->leftchild, vis);preorder(t->rightchild, vis);}}//中序遍历void inorder(struct tree *t, void vis(char name)) {if (t != NULL) {inorder(t->leftchild, vis);vis(t->name);inorder(t->rightchild, vis);}}//后序遍历void postorder(struct tree *t, void vis(char name)) {if (t != NULL) {postorder(t->leftchild, vis);postorder(t->rightchild, vis);vis(t->name);}}//寻找对应中序序列中和前序序列相对应的结点的位置int bfs(char ch[],char name) {int i(0);while (ch[i] != name) ++i;return i;}//找到左⼦树的位置int seek_left(int flag[], int t){int temp;temp = t;while (flag[temp] != 1 && temp >= 0)temp--;if (flag[temp] == 1)return temp;else return -1;}//找到右⼦树的位置int seek_right(int flag[], int t){int temp;temp = t;while (flag[temp] != 1 && temp <= 10000)temp++;if (flag[temp] == 1)return temp;else return -1;}int main() {while (1) {cout << " ***************唯⼀确定⼀颗⼆叉树***************" << endl;cout << " * *" << endl;cout << " * 给定前序序列和中序序列唯⼀确定⼀颗⼆叉树 *" << endl; cout << " * *" << endl;cout << " ************************************************" << endl;struct tree *root; //定义根节点init(&root); //创建根节点struct tree *node_tree[maxint]; //⼆叉树中的结点int flag[maxint]; //标记数组int left, right;memset(flag, 0, sizeof flag); //标记数组全部赋值为0cout << "请输⼊前序序列:";cin >> ch1;cout << "请输⼊中序序列:";cin >> ch2;length = strlen(ch1);char node; //前序序列中的结点int num; //中序序列中对应前序序列结点的位置for (int i = 0; i < length; ++i) {node = ch1[i];num = bfs(ch2, node);left = seek_left(flag, num); //找到左⼦树位置right = seek_right(flag, num); //找到右⼦树位置if (left == -1 && right == -1) { //第⼀次的时候肯定会执⾏这个条件后⾯的语句 node_tree[num] = build_ltree(root, node);flag[num] = 1;}else if (left != -1 && node_tree[left]->rightchild == NULL) {node_tree[num] = build_rtree(node_tree[left], node);flag[num] = 1;}else if (right != -1 && node_tree[right]->leftchild == NULL) {node_tree[num] = build_ltree(node_tree[right], node);}}cout << "此⼆叉树的结构是:" << endl << endl;print_tree(root, 0);cout << "此⼆叉树的前序序列为:";preorder(root->leftchild, vis);cout << endl;cout << "此⼆叉树的中序序列为:";inorder(root->leftchild, vis);cout << endl;cout << "此⼆叉树的后序序列为:";postorder(root->leftchild, vis);cout << endl << endl << endl;}return0;}效果图总结断更⼀个⽉后,重新写博。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

从先序和中序遍历结果恢复二叉树第16组
一、题目重述:
从先序和中序遍历结果恢复二叉树。

二、题目分析:
输入先序序列和中序序列,从而得到一个完整的二叉树。

例如:输入先序序列“GDAFEMHZ”和中序序列“ADEFGHMZ”,得到上图二叉树,用括号表示法输出,最终得出结果G(D(A,F(E)),M(H,Z))。

三、做法步骤:
1.输入先序序列和中序序列:
1)分别判断先序序列和中序序列输入是否正确
2)判断两序列长度是否相等;
3)判断两序列中所含元素是否相同;
4)若先序和中序均输入正确,且两序列长度相等,所含元素相同,则向下进
行;
2.找到root结点,每次先序遍历的序列的第一个数即为root结点;
3.找到根结点在中序遍历序列中的位置i,那么i左面的元素为树的左子树,i 右面的元素为树的右子树;
4.根据中序遍历序列中的左右子树,找到先序遍历序列中对应的部分,即将先序序列和中序序列按照其左右子树分别拆分成两个新的序列;
5.进入左子树重复上述过程;
6.进入右子树重复上述过程;
7.得到还原后的二叉树,用括号表示法输出。

四、算法示例:
五、代码:
1.#include<stdio.h>
2.#include<stdlib.h>
3.#include<string.h>
4.
5.typedef struct BiTNode{//定义二叉树
6.char data;
7.struct BiTNode*lchild,*rchild;
8.}BiTNode,*BiTree;
9.
10.BiTree CreatBinTree(char*pre,char*in,int n)
11.{
12.BiTree T;
13.int i;
14.if(n<=0)return NULL;
15.T=(BiTree)malloc(sizeof(BiTNode));
16.T->data=pre[0];
17.for(i=0;i<n;i++)//找到根结点在中序序列中的位置i
18.{
19.if(in[i]==pre[0])break;
20.}
21.T->lchild=CreatBinTree(pre+1,in,i);//递归操作左子树
22.T->rchild=CreatBinTree(pre+i+1,in+i+1,n-i-1);//递归操作右子树
23.return T;
24.}
25.
26.void PrinTree(BiTree b)//括号表示法
27.{
28.if(b!=NULL)
29.{
30.printf("%c",b->data);
31.if(b->lchild!=NULL||b->rchild!=NULL)
32.{
33.printf("(");
34.PrinTree(b->lchild);
35.if(b->rchild!=NULL)
36.printf(",");
37.PrinTree(b->rchild);
38.printf(")");
39.}
40.}
41.}
42.
43.int main()
44.{
45.BiTree T;
46.char pre[100];
47.char in[100];
48.int length1,length2;
49.int i,j,count=0,k1=0,k2=0;
50.printf("输入先序序列:");
51.scanf("%s",pre);
52.length1=strlen(pre);
53.for(i=0;i<length1;i++)//判断先序序列中是否有重复元素
54.{
55.for(j=0;j<length1;j++)
56.{
57.if(pre[i]==pre[j])k1++;
58.}
59.}
60.if(k1!=length1)
61.{
62.printf("先序序列存在重复元素,输入错误!");
63.return0;
64.}
65.printf("输入中序序列:");
66.scanf("%s",in);
67.length2=strlen(in);
68.for(i=0;i<length2;i++)//判断中序序列中是否有重复元素
69.{
70.for(j=0;j<length2;j++)
71.{
72.if(in[i]==in[j])k2++;
73.}
74.}
75.if(k2!=length2)
76.{
77.printf("中序序列存在重复元素,输入错误!");
78.return0;
79.}
80.if(length1!=length2)//判断两个序列长度是否相同
81.{
82.printf("两个序列长度不相等,请重新输入");
83.}
84.else
85.{
86.for(i=0;i<length1;i++)
87.{
88.for(j=0;j<length2;j++)
89.{
90.if(pre[i]==in[j])count++;
91.}
92.}
93.if(count!=length1)printf("两个序列所含元素不同,输入错误");//判断两个序
列是否含有相同元素
94.else
95.{
96.T=CreatBinTree(pre,in,length1);
97.PrinTree(T);
98.return0;
99.}
100.}
101.}
六、测试结果:。

相关文档
最新文档