Create Preorder Using Postorder and Leaf Nodes Array

In input, there are two arrays that are given to us. One array is an integer array that represents postorder traversal of a binary tree, and the other array is a Boolean array that provides information about the leaf nodes. For every element in the postorder array, there is a corresponding Boolean value in the leaf nodes array. If the value in the Boolean array is true, then the given elements will comprise a leaf node in the binary tree; otherwise, it will not. Our task is to display the preorder traversal of the binary tree whose postorder traversal is given in the input. Note that there might be a possibility that multiple binary trees exist of the same postorder traversal. One has to consider any one of the binary trees and according to that preorder traversal has to be displayed on the console.

Example 1:

Input

postorder = { 140, 120, 150, 160, 130, 110, 170 }

isLeaf = { true, false, true, true, false, false, false }

Output: { 170, 110, 120, 140, 130, 150, 160 }

Approach

The concept is to first identify the root node of the binary tree with the help of the last key in the postorder sequence. Then with the help of the given Boolean array, we check whether the root node is a leaf node or an internal node. If the root node is an internal node, we recursively create its left and right subtrees. The following is the implementation of the mentioned approach.

FileName: CreatePreorder.java

// Java implementation for
// the above approach
import java.util.*;
public class CreatePreorder
{

static int s;

// for storing the tree nodes
static class TreeNode
{
int value;
TreeNode lftchild;
TreeNode rghtchild;

// constructor of the class
TreeNode(int _val, TreeNode _lftchild, TreeNode _rghtchild)
{
value = _val;
lftchild = _lftchild;
rghtchild = _rghtchild;
}
};

// method for generating the binary tree
// from the provided postorder traversal sequence
// and from the non-leaf and leaf node information.
public TreeNode makeBinaryTree(int postorder[], boolean isLeafArr[])
{
// Using The Base condition
if (s < 0)
{
return null;
}
TreeNode rt = new TreeNode(postorder[s], null, null);
boolean isInternalNde = !isLeafArr[s];
s = s - 1;

// if the internal node, then make the right and
// the left child
if (isInternalNde)
{
rt.rghtchild = makeBinaryTree(postorder, isLeafArr);
rt.lftchild = makeBinaryTree(postorder, isLeafArr);
}
return rt;
}

// method that displays the pre-order traversal
// of the binary tree.
public void preorder(TreeNode rt)
{

// handling the base case
if (rt == null) 
{
return;
}

// Create an empty stack and push root to it
Stack<TreeNode> ndeStack = new Stack<TreeNode>();
ndeStack.push(rt);

// One by one, pop all of the items. perform the following for each item that is popped
// 1) display it
// 2) push the right child
// 3) push the left child
// It is worth mentioning here that the right child is inserted
// first into the stack so that the left child is processed first 
while (ndeStack.empty() == false) 
{

// Pop the peek item from the stack and display it
TreeNode myNde = ndeStack.peek();
System.out.print(myNde.value + " ");
ndeStack.pop();

// Push the left and the right children of the popped node to the stack
if (myNde.rghtchild != null) 
{
ndeStack.push(myNde.rghtchild);
}
if (myNde.lftchild != null) 
{
ndeStack.push(myNde.lftchild);
}
}
}

// main method
public static void main(String[] argvs)
{
// postorder array
int postorderArr[] = { 140, 120, 150, 160, 130, 110, 170 };

// boolean array that tells which node is a leaf node and which node is not
boolean isLeafArr[] = { true, false, true, true, false, false, false };

s = postorderArr.length - 1; // assigning the value to the static variable s

// create an object of the class CreatePreorder
CreatePreorder obj = new CreatePreorder();

// invoking the method makeBinaryTree()
TreeNode rt = obj.makeBinaryTree(postorderArr, isLeafArr);
System.out.println("For a tree whose post order traversal is: ");
for(int i = 0; i < postorderArr.length; i++)
{
    System.out.print(postorderArr[i] + " ");
}
System.out.println(" \n " );
System.out.println("The preorder traversal is: ");
// invoking the method preorder()
obj.preorder(rt);
}
}

Output:

For a tree whose post order traversal is: 
140 120 150 160 130 110 170  
 
The preorder traversal is: 
170 110 120 140 130 150 160

Complexity Analysis: The time complexity, as well as the space complexity of the program, is O(n), where n is the number of elements present in the preorder array.

Next TopicDisplay Leaf nodes from Preorder of a BST in Java

← prev next →