Check if a binary tree is subtree of another binary tree - algorithm

Question

To check if a binary tree is subtree of another tree ,I was thinking that lets store the inorder and preorder traversal of the tree as strings(like assigning characters to each node) and then do a substring match to check if the tree is subtree or not. Will this approach work ?

Answer 1

Not sure who picked #genisage's answer as correct. Inorder with preorder/postorder substring approach is the best solution for this problem. In the example #genisage mentioned pre-order traversals are 1 2 and 2 2 1. 1 2 is not a substring of 2 2 1 and the answer is false.

Answer 2

no, it won't. consider a possible subtree consisting of a root node containing 1, and a left child containing 2. And a second tree with root 1, left child 2, and right child 1.
It's clear that the first is not a subtree of the second but your method would say that it is since the preorder traversals are 1 2 and 1 2 1, and the inorder traversals are 2 1 and 2 1 1.
You would need to add null values when they’re encountered to differentiate, making the preorder traversal 1 2 null and 1 2 1 and the inorder 2 1 null and 2 1 1 which is not a sub tree.

Answer 3

Given two binary trees, check if the first tree is subtree of the second one. A subtree of a tree T is a tree S consisting of a node in T and all of its descendants in T. The subtree corresponding to the root node is the entire tree; the subtree corresponding to any other node is called a proper subtree.
For example, in the following case, tree S is a subtree of tree T.
Tree S
10
/ \
4 6
\
30
Tree T
26
/ \
10 3
/ \ \
4 6 3
\
30
Traverse the tree T in preorder fashion. For every visited node in the traversal, see if the subtree rooted with this node is identical to S.
#include <stdio.h>
#include <stdlib.h>
/* A binary tree node has data, left child and right child */
struct node
{
int data;
struct node* left;
struct node* right;
};
/* A utility function to check whether trees with roots as root1 and root2 are identical or not */
bool areIdentical(struct node * root1, struct node *root2)
{
/* base cases */
if(root1 == NULL && root2 == NULL)
return true;
if(root1 == NULL || root2 == NULL)
return false;
/* Check if the data of both roots is same and data of left and right subtrees are also same */
return (root1->data == root2->data &&
areIdentical(root1->left, root2->left) &&
areIdentical(root1->right, root2->right) );
}
/* This function returns true if S is a subtree of T, otherwise false */
bool isSubtree(struct node *T, struct node *S)
{
/* base cases */
if (S == NULL)
return true;
if (T == NULL)
return false;
/* Check the tree with root as current node */
if (areIdentical(T, S))
return true;
/* If the tree with root as current node doesn't match then
try left and right subtrees one by one */
return isSubtree(T->left, S) ||
isSubtree(T->right, S);
}
/* Helper function that allocates a new node with the given data
and NULL left and right pointers. */
struct node* newNode(int data)
{
struct node* node = (struct node*)malloc(sizeof(struct node));
node->data = data;
node->left = NULL;
node->right = NULL;
return(node);
}
/* Driver program to test above function */
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");
getchar();
return 0;
}
Output: Tree S is subtree of tree T