实验四：二叉树的应用

实验四：二叉树的应用

【问题描述】：

基于实验三设计的ADT，对输入的两棵二叉树A和B，判断B是不是A的子树。设T是一棵树，a是T中的一个顶点，由a以及a的所有后裔（后代）导出的子图称为树T的子树。如图：二叉树B就是二叉树A的一棵子树，而二叉树C不是二叉树A的子树。

【输入形式】

每个输入文件的第一行为二叉树A的前序遍历顺序表示法（N≤30）。二叉树B的前序遍历顺序表示法。

注意：用“#”代表空指针NULL。

【输出形式】

yes 代表二叉树B就是二叉树A的一棵子树。

no 代表二叉树B不是二叉树A的一棵子树。

【样例输入1】

​ AB##C##

​ AB##C##

【样例输出1】

​ yes
【样例说明1】

​ 二叉树B是二叉树A的一棵子树

【样例输入2】

​ ABD##E##CGH###F##

​ CGH####

【样例输出2】

​ no
【样例说明2】

​ 二叉树B不是二叉树A的一棵子树

【解题思路】：

记输入的两个二叉树为分别为a1，a2

记a2的根节点对应的值为h

1）先创建二叉树的类来储存输入的元素

2）a1中进行遍历查找h。

3）在未查找到h，则输出‘no’并return

4）若查到h则返回以h为根节点的二叉树记做e

5）对a2和e分别进行先序遍历，并将遍历到的节点装入两个容器中，若遍历到的左节点或右节点为空则将‘#’装入容器

（若不进行插“#”的操作，不能保证两个二叉树前序遍历相同则两个二叉树相同）

6）对两个容器进行size的比较，

若不同则输出“no”并返回

若相同则对两个容器进行遍历逐个比较若有不同输出“no”并返回

直到遍历完容器中所有元素，此时说明两个容器元素相同，即两个二叉树相同，也说明a2为a1的子树，输出“yes”并return

【具体实现代码】：

template<typename E>
class BinNode//BinNode类的声明部分
{
private:
	BinNode* lc;
	BinNode* rc;
	E elem;
public:
	BinNode();
	BinNode(E tmp, BinNode* l = NULL, BinNode* r = NULL);
	BinNode* left();
	BinNode* right();
	void setLeft(BinNode* l);
	void setRight(BinNode* r);
	void setValue(E tmp);
	E getValue();
	bool isLeaf();
};
template<typename E>
class BinTree//BinTree类的主要部分
{
private:
	BinNode<E>* root;
public:BinNode<E>* find(BinNode<E>* tmp, E e);
	BinTree();
	~BinTree();
	bool BinTreeEmpty();
	BinNode<E>* getRoot();
    BinNode<E>* find(BinNode<E>* tmp, E e);
};
template<typename E>
BinNode<E>* creatBinaryTree(string s[], int& x, int n);//构建二叉树
void creatBinaryTree(BinTree<string>* BT);
template<typename E>
BinNode<E>* BinTree<E>::find(BinNode<E>* tmp, E e)//find 函数的实现部分
{
if (tmp == NULL)return NULL;//没找到返回null
	else if (tmp->getValue() == e)return tmp;//如果这个节点对应的值为所查找的值，返回以该节点为根节点的二叉树
	else//这个节点不是所查找的
	{
		BinNode<E>* tmp1 = find(tmp->left(), e);//从左左子树进行查找
		if (tmp1)return tmp1;//找到了返回改节点
		else//没找到
		{
			BinNode<E>* tmp2 = find(tmp->right(), e);//从右节点继续查找

			if (tmp2)return tmp2;//找到了返回改节点

		}
	}
	return NULL; 
}
template<typename E>
void preOrder1(BinNode<E>* tmp, vector< string>& ve)//前序遍历函数
{
	if (tmp == NULL)
	{
		ve.push_back("#");//为空则插入#作为标记，以此来保证其特殊性
		return ;
	}
	ve.push_back(tmp->getValue());//插入容器中
	preOrder1(tmp->left(),ve);
	preOrder1(tmp->right(),ve);

}
bool compare(BinNode<string>* s, BinNode<string>* s1)//两个节点的比较函数
{
	vector<string> ve,ve1;
	preOrder1(s, ve);//将二叉树的元素装入容器中
	preOrder1(s1, ve1);
	if (ve.size() != ve1.size())return 0;
	else
	{
		for (int i = 0; i < ve.size(); i++)//遍历比较两个容器
		{
		
			if (ve[i] != ve1[i])return 0;
		}
	}
	return 1;
}
//main 函数：
BinTree<string>* BT = new BinTree<string>;
	creatBinaryTree(BT);
	BinTree<string>* BT1 = new BinTree<string>;
	creatBinaryTree(BT1);
	BinNode<string>* tem = BT->find(BT->getRoot(), BT1->getRoot()->getValue());
	if (tem!=NULL)
	{	
		if (compare(tem, BT1->getRoot()))
		{
			cout << "yes";
			return 0;
		}
	}
	else cout << "no";
	cout << "no";

附：完整代码（分文件编写）

#pragma once 
#include<iostream>
#include"string"
#include<queue>
using namespace std;
template<typename E>
class BinNode
{
   
private:
	BinNode* lc;
	BinNode* rc;
	E elem;
public:
	BinNode()
		;
	BinNode(E tmp, BinNode* l = NULL, BinNode* r = NULL)
		;
	BinNode* left()
		;
	BinNode* right()
		;
	void setLeft(BinNode* l)
		;
	void setRight(BinNode* r)
		;
	void setValue(E tmp)
		;
	E getValue()
		;
	bool isLeaf()
		;
};

template<typename E>
class BinTree
{
   
private:
	BinNode<E>* root;
	void clear(BinNode<E>* r)
		;
	void  preOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))
		;
	void inOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))
		;
	void postOrder(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))
		;
	void LevelOrderTranverse(BinNode<E>* tmp, void(*visit)(BinNode<E>* node))
		;
	int BinTreeDepth(BinNode<E>* tmp)
		;
	int BinTreeNodes(BinNode<E>* tmp)
		;
	int BinTreeHeight(BinNode<E>* tmp)
		;
	int BinTreeLeafs(BinNode<E>* tmp)
		;
	
public:BinNode<E>* find(BinNode<E>* tmp, E e)
		;
	BinTree()
		;
	~BinTree()
		;
	bool BinTreeEmpty()
		;
	BinNode<E>* getRoot()
		;
	void setRoot(BinNode<E>* r)
		;

	void clear()
		;
	void preOrder(void(*visit)(BinNode<E>* node))
		;
	void inOrder(void(*visit)(BinNode<E>* node)) 
		;
	void postOrder(void(*visit)(BinNode<E>* node))
		;
	void LevelOrderTranverse(