判断二叉树是否包含另一棵二叉树或者树的子结构

//根据前序遍历和中序遍历还原构造二叉树
//判断二叉树A是否包含二叉树B
//思路：1）首先遍历树A,找到一个节点值与B的根节点值相同
//       2)再以步骤1）找到的节点值，开始比较树A的子树是包含树B

#include <iostream>
#include <stack>
using namespace std;

//树的前序遍历
int preOrder1[] = {10, 6, 4, 8, 14, 12, 16};
//树的中序遍历
int inOrder1[] =  {4, 6, 8, 10, 12, 14, 16};

int preOrder2[] = {8,9,2};
int inOrder2[] =  {9,8,2};


typedef struct Node_
{
	Node_ * left, * right;
	int data;
	bool visit;
}Node;

//重建二叉树
//
Node * RebuildBTree(Node * & root,int preOrder[], int inOrder[],  int n, int pl, int pr, int il, int ir)
{
	int i = 0;

	for (i = il;i <= ir; ++i)
	{
		if (inOrder[i] == preOrder[pl])
		{
			break;
		}
	}
	int k = i - il;
	if (i <= ir)
	{
		root = new Node();
		root->data = inOrder[i];
	}
	else
	{
		root = NULL;
		return root;
	}
	root->left = RebuildBTree(root->left,preOrder,inOrder, k,pl + 1 ,pl + k , il, i-1);
	root->right = RebuildBTree(root->right,preOrder,inOrder, ir - i ,pl + k + 1,pr, i+1, ir);

	return root;
}

//根据找到的节点，判断树parent 是否包含child 树
bool TreeMatch(Node * parent, Node * child)
{
	if (!child)
	{
		return true;
	}

	if (!parent)
	{
		return false;
	}

	if(parent->data != child->data)
	{
		return false;
	}

	return TreeMatch(parent->left, child->left) && TreeMatch(parent->right, parent->right);;
}

//遍历树Parent,在parent树中找到与child树根节点值相同的节点
bool IsSubTree(Node * parent, Node * child)
{
	bool res = false;
	if (child == 0 ) //空子树是任何树（包括空树）的子树
	{
		return true;
	}

	if(parent && child)
	{
		if (parent->data == child->data)
		{
			res = TreeMatch(parent, child);
		}

		if (!res)
		{
			res = IsSubTree(parent->left, child);
		}

		if (!res)
		{
			res = IsSubTree(parent->right, child);
		}
	}

	return res;
}

void NonRecursionInorder(Node * root)
{
	if (!root)
	{
		return;
	}

	stack<Node *> st;
	st.push(root);

	while(!st.empty())
	{
		Node * cur = st.top();

		while(cur)
		{
			st.push(cur->left);
			cur = cur->left;
		}
		st.pop();

		if(!st.empty())
		{
			cur = st.top();
			st.pop();
			printf("%d ", cur->data);
			st.push(cur->right);
		}
	}

}

int main()
{
	Node * ParentRoot = 0;
	Node * ChildRoot = 0;
	int n1 = sizeof(preOrder1) / sizeof(preOrder1[0]);
	ParentRoot = RebuildBTree(ParentRoot,preOrder1, inOrder1, n1, 0, n1-1, 0, n1 - 1);

	printf("二叉树Parent的中序遍历：");
	NonRecursionInorder(ParentRoot);

	int n2 = sizeof(preOrder2) / sizeof(preOrder2[0]);
	ChildRoot = RebuildBTree(ChildRoot,preOrder2, inOrder2, n2, 0, n2-1, 0, n2 - 1);
	printf("\r\n二叉树Child的中序遍历：");
	NonRecursionInorder(ChildRoot);
	bool res = IsSubTree(ParentRoot, ChildRoot);

	printf("\r\n%s", res==true?"YES":"NO");
	return 0;
}