bool isSubTree(node *T, node *S){
if(T == NULL)
return false;
if(T->data == S->data && isSimilar(T, S))
return true;
else{
return isSubTree(T->left, S) || isSubTree(T->right, S);
}
}
bool isSubTree(TreeNode *node1, TreeNode *node2)
{
//若B是空，则无论A是否为空，B都是A的子结构，空树是任何树的子结构
if (node2 == NULL)
return true;
if (node1 == NULL)
return false;
//若非空，则当结点值相同，并且左右子树都满足子结构条件时，B是A的子结构
if (node1->val == node2->val)
return isSubTree(node1->left, node2->left) && isSubTree(node1->right, node2->right);
else //结点值不同，肯定不是子结构
return false;
}
/*
判断pTree2是否是与pTree1有共同的根节点的pTree1子树
*/
bool isSubTree(BTNode *pTree1,int index1,BTNode *pTree2,int index2)
{
//前两个if语句不能颠倒，不然当pTree1和pTree2相同时，会误判为false
if(index2 == -1)
return true;
if(index1 == -1)
return false;
if(pTree1[index1].data != pTree2[index2].data)
return false;
else
return isSubTree(pTree1,pTree1[index1].lchild,pTree2,pTree2[index2].lchild) &&
isSubTree(pTree1,pTree1[index1].rchild,pTree2,pTree2[index2].rchild);
}
// check whether BST s is BST t's subtree.
bool isSubTree(Node *t, Node *s)
{
if (t==NULL)
return false;
if (s==NULL)
return true;
if (t->data == s->data)
return isSameTree(t,s);
if (t->data < s->data) {
return isSubTree(t->right, s);
}
if (t->data > s->data) {
return isSubTree(t->left, s);
}
}
bool isSubTree(BTreeNode *tree1, BTreeNode *tree2) {
// find a node in tree1 with the same value as the root of tree2 ;
bool isASubTree = false;
if(NULL != tree1 && NULL != tree2) {
if(rootVal == node->val) {
isASubTree = testMatch(node, tree2);
}
if(!isASubTree) {
isASubTree = isSubTree(node->left, tree2);
}
if(!isASubTree) {
isASubTree = isSubTree(node->right, tree2);
}
}
return isASubTree;
}
/// Get the current size of the <index> child item
vec2 UIComponentTreeView::getItemSize(int index)
{
if(isSubTree(index))
{
// This item is an arbitrarily complex tree, need to get that tree header + spacing + each item size
UIView* subTreeContainer = mParent->getChild(index)->getChild(1);
UIComponentTreeView* subTree = mParent->getChild(index)->getChild(1)->getComponent<UIComponentTreeView>();
// A subtree item has size of the header + spacing + container of items
return subTree->getSize() + vec2(0.f, mLineHeight + mSpacing);
}
else
{
//Log("simple item");
// This item is a individual "file" and is only a fixed height
return vec2(mParent->getChild(index)->getSize().x, mLineHeight);
}
}
/*
判断pTree1是否包含pTree2
*/
bool isContainTree(BTNode *pTree1,int index1,BTNode *pTree2,int index2)
{
if(pTree1==NULL || pTree2==NULL)
return false;
if(index1==-1 || index2==-1)
return false;
bool result = false;
if(pTree1[index1].data == pTree2[index2].data)
result = isSubTree(pTree1,index1,pTree2,index2);
//如果pTree1[index1].lchild为-1，下次递归时会通过index1==-1的判断返回false，
//因此这里不需要再加上pTree1[index1].lchild!=-1的判断条件
if(!result)
result = isContainTree(pTree1,pTree1[index1].lchild,pTree2,index2);
if(!result)
result = isContainTree(pTree1,pTree1[index1].rchild,pTree2,index2);
return result;
}
int main(){
/* Construct the following tree
26
/ \
10 3
/ \ \
4 6 3
\
30
*/
struct node *T = newNode(26);
T->right = newNode(3);
T->right->right = newNode(3);
T->left = newNode(10);
T->left->left = newNode(4);
T->left->left->right = newNode(30);
T->left->right = newNode(6);
/* Construct the following tree
10
/ \
4 6
\
30
*/
struct node *S = newNode(10);
S->right = newNode(6);
S->left = newNode(4);
S->left->right = newNode(30);
if (isSubTree(T, S))
printf("Tree S is subtree of tree T");
else
printf("Tree S is not a subtree of tree T");
return 0;
}
void TEST_subtree()
{
std::cout << "TEST whether BST s is BST t's subtree.\n";
int t[] = {1,2,3,4,5,6,7,8,9,10};
int len_t = sizeof(t)/sizeof(t[0]);
int s[] = {1,2,3,4};
int len_s = sizeof(s)/sizeof(s[0]);
BST bst_t = BST(t, len_t);
std::cout << "Tree t: \n";
bst_t.printPretty();
BST bst_s = BST(s, len_s);
std::cout << "Tree s: \n";
bst_s.printPretty();
if ( isSubTree(bst_t.getRoot(), bst_s.getRoot()) ) {
std::cout << "Tree s is Tree t's subtree.\n";
} else {
std::cout << "Tree s is NOT Tree t's subtree.\n";
}
}
bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
{
if (pRoot1 == NULL || pRoot2 == NULL)
return false;
return isSubTree(pRoot1, pRoot2) || HasSubtree(pRoot1->left, pRoot2) || HasSubtree(pRoot1->right, pRoot2);
}
