实验九 二叉树

一、实验目的与要求

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右侧的字符串为右子树的内容。同时回溯到先序遍历字符串中，可锁定左子树的始末下标和右子树的始末下标。

根据树的定义，每一个子树可作为一棵新的树。于是我们将左子树和右子树分别看作新的两个树，确定好新的prestring和instring起始下标之后，重新进行上述操作来确定整个树的空间结构，直至左子树或右子树为空树。最后返回整个树。

在确定整个树的空间结构后，通过递归的后序遍历法【左子树->右子树->根】输出整个树的结点数据。

最后通过主函数依次调用上述算法函数。

2 分析算法时间复杂度

在寻找先序字符串中当前元素在中序字符串中的位置的时候，使用了for循环遍历instring里面的所有结点数据。由此可见，时间复杂度为O(n)。整个递归调用的时间复杂度为O(n logn)。

    前俩个递归调用的时候，均通过二分法处理两个遍历字符串，从而进行下一次函数调用。第三个递归调用的时候，也与上述两个递归类似，先通过锁定根结点，分为左子树和右子树继续遍历。由此可见，时间复杂度均为O(n/2)。