【数据结构】实验九：二叉树

实验九 二叉树

一、实验目的与要求

1）理解二叉树的类型定义；

2）掌握二叉树的存储方式及基于存储结构的基本操作实现；

二、实验内容

1. 二叉树的结点定义如下：

struct TreeNode

{

int m_nvalue;

TreeNode* m_pLeft;

TreeNode* m_pRight;

};

输入二叉树中的两个结点，输出这两个结点在树中的最近公共祖先结点。

说明：最近公共祖先定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个结点也可以是它自己的祖先）。

2. 某同学非常喜欢玩二叉树。最喜欢的游戏是用结点中的大写字母构造查找二叉树。这是他构造的二叉树：

他为每棵树写下先序遍历和中序遍历两个字符串，例如：对于上面构造的树，先序遍历为DBACEGF，中序遍历为ABCDEFG。几年后，他想重新构造这棵树，请你来编写一个程序帮他实现基于上述遍历序列构造树。

题意解析：根据所给的两串序列，分别是前序和中序，求出二叉树的后序。

三、实验结果

1）简述算法步骤：

2）分析算法时间复杂度：

题目1：

0 实验代码及结果

#include <iostream>
#include <cstdio>
#include <vector>
using namespace std;#define Max 100
vector<int> E[Max]; 
int parent[Max];     
int depth[Max];     //构造递归的树  v->当前结点 p->当前的双亲结点 d->当前结点深度 
void BuildTree(int v,int p,int d){parent[v]=p;depth[v]=d;for(int i=0;i<E[v].size();i++){if(E[v][i]!=p){BuildTree(E[v][i],v,d+1);}}
}//lowest common ancestor的寻找函数 
int LCA(int u,int v){//深度不同时，用双亲结点替换 while(depth[u]!=depth[v]){if(depth[v]<depth[u]){u=parent[u];}else{v=parent[v];}}//同深度时，同时迭代寻找ancestor while(u!=v){u=parent[u];v=parent[v];}return v;//返回公共祖先 
}int main(){int n,root=1;//n->总结点数  root->根结点 //root需要定义!!!!!!!!!!!!! cout<<"请输入总结点数："<<endl;cin>>n;if(n==1){cout<<"输入错误！不能只有一个结点！"<<endl;return 0;}//i<n-1 根结点无双亲，所以少输入一次 for(int i=0;i<n-1;i++){int u,v;cout<<"请输入双亲结点编号及其孩子结点编号："<<endl;cin>>u>>v;E[u].push_back(v);E[v].push_back(u);  }BuildTree(root,-1,0);//根结点双亲为-1，深度为0 int u,v;cout<<"请输入两个待测结点的编号：" <<endl;cin>>u>>v;cout<<"其LCA为："<<LCA(u,v)<<endl;return 0;
}

实验报告测试用例的二叉树如下图所示：

代码测试结果如下图所示：

1 简述算法步骤

定义存储当前结点数据、双亲结点、当前结点深度的数组，并规定最大范围为100。

构造递归结构存储的数，存储当前结点的双亲结点和深度，然后通过for循环遍历，利用递归构造子树。在for循环中，如果遍历发现当前结点与双亲结点不同，即当前结点不是叶子结点，那么继续调用BuildTree函数构造子树，并将当前深度加一。

寻找最近公共祖先时，先判断两个结点的深度是否相同。如果深度不同，则先回溯深度较深的结点，寻找其与另外一个结点深度相同时的祖先。回溯完以后，此时u、v深度相同，直接比较u、v结点是否相同。如果结点不同，则分别向上回溯一个祖先，再判断其祖先是否相同。最后两个结点回溯到相同值，返回其中一个结点即可。

最后通过vector自带函数和for循环，将预设的树进行入栈并构造。

2 分析算法时间复杂度

在利用递归创建树时，利用了for循环遍历双亲合集，来判断当前结点的双亲结点是否已经被存入。由此可见，时间复杂度为O(n^2)。

在LCA函数中，通过第一个while循环收缩较远结点的深度进行回溯，通过第二个while循环同时收缩两个结点的深度进行回溯。由此可见，时间复杂度均为O(n)。

在主函数输入预设树的基本信息时，利用了for循环将每一组【双亲结点+孩子结点】存入vector中。由此可见，时间复杂度为O(n)。

题目2：

0 实验代码及结果

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;typedef struct Node{char data;//数据域 struct Node *lchild,*rchild;//左孩子结点+右孩子结点 
}Node,*BiTree;char PreString[30],InString[30];//先序和中序遍历字符串 maxsize=30 //根据先序+中序，重新构造原来的树，即BiTree T = new Node(); 
BiTree Build(char *PreString,char *InString,int s1,int e1,int s2,int e2){//s：start e：end BiTree T = new Node();T -> data = PreString[s1];int rootIdx;//根结点所在序号for(int i = s2;i <= e2;i++){if(PreString[s1] == InString[i]){rootIdx = i;//寻找先序字符串中当前元素在中序字符串中的位置 break;//寻觅结束 }}int llen = rootIdx - s2;//左 为 根-初始 int rlen = e2 - rootIdx;//右 为 len（in）-根 if(llen != 0){//左 非空 T -> lchild = new Node();T -> lchild = Build(PreString,InString,s1 + 1,s1 + llen,s2,s2 + llen - 1);//继续在左子树里面重复上述操作；//prestring: start=s1+1; end=s1+llen//instring: start=s2; end=s2+llen-1 }else{T -> lchild = NULL;}if(rlen != 0){//右 非空 T -> rchild = new Node();T -> rchild = Build(PreString,InString,e1 - rlen + 1,e1,e2 - rlen + 1,e2);//继续在右子树里面重复上述操作；//pre: start=e1-rlen+1; end=e1//in: start=e2-rlen+1; end=e2}else{T -> rchild = NULL;}return T;
}//后序遍历 -> 递归输出 
void PostOrder(BiTree T){if(T != NULL){ //树非空 PostOrder(T -> lchild); //走左子树 PostOrder(T -> rchild); //走右子树 cout<<T -> data; //走根 or 叶子结点 }
}int main(){cout<<"请输入先序遍历字符串：";cin>>PreString;cout<<"请输入中序遍历字符串：";cin>>InString;BiTree T = NULL; //构建空树 int e1=strlen(PreString)-1,e2=strlen(InString)-1;//两个字符串下标位数 T = Build(PreString,InString,0,e1,0,e2); //通过先序遍历+中序遍历推断树结构 cout<<"此二叉树的后序遍历为：";PostOrder(T);//后序遍历输出该树 return 0;
}

题干给的先序遍历+中序遍历构成的二叉树如下图所示：

代码测试结果如下图所示：

1 简述算法步骤

构造一个二叉树，属性携带当前结点数据、当前结点左孩子指针和当前结点右孩子指针。

根据先序遍历【根->左子树->右子树】的特点可知，先序遍历字符串中的第一个结点必然为根，然后通过for循环在中序遍历字符串中寻找与当前结点数据相同的结点，并锁定其在中序遍历字符串中的位置为rootIdx。此时，在中序遍历字符串中，rootIdx左侧的字符串为左子树的内容，rootIdx右侧的字符串为右子树的内容。同时回溯到先序遍历字符串中，可锁定左子树的始末下标和右子树的始末下标。