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

//根据前序遍历和中序遍历还原构造二叉树

//判断二叉树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;
}