Construct Full Binary Tree using its Preorder Traversal and Preorder Traversal of its Mirror Tree

We have to create a software that represents these two Pre-order traversals to develop the binary tree given two arrays that produces Pre-order traversals of a full binary tree and its mirror tree.

A full binary tree is a binary tree which tree has one or more children at each node.

It should be noted that these two traversals cannot be used to build a general binary tree. However, we may construct a complete binary tree with the above traversals even without difficulty.

Example:

Construct Full Binary Tree using its Preorder Traversal and Preorder Traversal of its Mirror Tree

Method 1: Take the two provided arrays, preOrder[] = 1, 2, 5, 6, 4, 7, 8 and preOrderMirror[] = 1,4,8,7,2,6,5

The root of the tree is the leftmost element in both preOrder[] and preOrderMirror[]. The array size is bigger than one and the tree is full. The root's left child must be the value next to 1 in preOrder, and the root's right child must be the value next to 1 in preOrderMirror.

Here In this case, 1 is representing the root, 2 is representing the left child, and 4 is representing the right child.

How can I discover all the nodes in the left subtree?

We know that 2 is the root of all nodes in the left subtree and 4 is the root of all nodes in the right subtree. PreOrderMirror needs all the nodes from 2 be in the left subtree of root node 1, and all nodes from 4 and before 2 be in the right subtree of root node 1. Now that we know that the root is 1, the left subtree's elements are 2, 6, 5, and the right subtree's elements are 4, 8, 7.

           1
        /    \
       /      \
    {2,6,5}  {4,8,7}

We'll use the aforementioned strategy recursively to generate the following tree:

                  1
               /    \
              2      4
            /   \   /  \
           5     6 7    8

The aforesaid technique is implemented as follows:

C++ Program:

#include<bits/stdc++.h>
using namespace std;

struct Node
{
	int data;
	struct Node *left, *right;
};

Node* newNode (int data)
{
	Node *temp = new Node;
	temp->data = data;
	temp->left = temp->right = NULL;
	return temp;
}

void printInorder ( Node* node )
{
	if ( node == NULL )
		return;

	printInorder ( node->left );
	printf ( "%d ", node -> data );
	printInorder ( node -> right );
}
Node* constructBinaryTreeUtil ( int pre[], int preM[],
					int &preIndex, int l,int h,int size )
{
	if ( preIndex >= size || l > h )
		return NULL;

	Node* root = newNode ( pre[preIndex] );
		++(preIndex);

	if ( l == h )
		return root;
	
	int i;
	for ( i = l; i <= h; ++i )
		if ( pre [preIndex] == preM [i] )
			break;

	if ( i <= h )
	{
		root -> left = constructBinaryTreeUtil ( pre, preM,
									preIndex, i, h, size );
		root -> right = constructBinaryTreeUtil ( pre, preM,
								preIndex, l+1, i-1, size );
	}

	return root;
}

void constructBinaryTree ( Node* root,int pre[],
						int preMirror[], int size )
{
	int preIndex = 0;
	int preMIndex = 0;

	root = constructBinaryTreeUtil ( pre,preMirror,
							preIndex,0,size-1,size );

	printInorder (root);
}
int main ()
{
	int preOrder[] = { 1,2,5,6,4,7,8 };
	int preOrderMirror[] = { 1,4,8,7,2,6,5 };

	int size = sizeof (preOrder) / sizeof (preOrder[0]);

	Node* root = new Node;

	constructBinaryTree ( root,preOrder,preOrderMirror,size );

	return 0;
}

Output:

5 2 6 1 7 4 8

Here, we can see that the Time Complexity will be O(n²)

And, also the Auxiliary Space will be O(n).

Method 2: If we try to look closer, we can notice that the Post-order traversal of the original tree is the inverse of the Pre-order traversal of the mirror tree. Similarly to above, we can also build the tree from supplied Pre-order and Post-order traversals.

Next TopicFind Relative Complement of two Sorted Arrays

← prev next →