Display Leaf nodes from Preorder of a BST in Java

An input array is given to us. That input array is the preorder traversal of a Binary Search Tree (BST). The task is to detect and print the leaf nodes of the Binary Search Tree. A leaf node is a node of a tree that has no child.

Example 1:

Input

int preorderArr[] = {25, 20, 10, 5, 12, 22, 36, 30, 28, 40, 38, 48}

Output: {5, 12, 22, 28, 38, 48}

Explanation: The nodes of the values 5, 12, 22, 28, 38, and 48 are the leaf nodes.

Example 2:

Input

int preorderArr[] = {891, 326, 291, 531, 966}

Output: {291, 531, 966}

Explanation: The nodes of the values 291, 531, and 966 are the leaf nodes.

Simple Approach

The simple or the naïve approach is to get one more traversal. We know that if we get any of the two traversals from the three (inorder, preorder, and postorder), we can get the binary tree, and from that, we can easily get the leaf nodes. Preorder is already given to us. So, our task is to find either postorder traversal or the inorder traversal. We know that if we do the inorder traversal of a binary search tree, we get the value of nodes in the sorted order (property of a BST).

Thus, all we need to do is to create an array called inorderArr[]. Copy all of the elements of the preorderArr in it and sort the array inorderArr[]. Now, we have got the two traversals (one is preorder, and the other is inorder). All we need to do is to construct a binary search tree from these two traversals and then find out the leaf nodes in it and display it. The following program makes the concept clearer.

FileName: DisplayLeafBST.java

// importing Arrays and ArrayList that are
// required in the program
import java.util.Arrays;
import java.util.ArrayList;

// a class for creating nodes of the Binary Search Tree
class TreeNode 
{
// for holding the value of the node
int val;

// for holding the left child
TreeNode left;

// for holding the right child
TreeNode right;

// constructor of the class 
TreeNode(int x) 
{
val = x;
left = null;
right = null;
}
}


public class DisplayLeafBST
{
// a method that displays the leaf nodes of the Binary Search Tree
public void displayLeafNodes(ArrayList<Integer> leafNodeList)
{
int size = leafNodeList.size();

for(int i = 0 ; i < size; i++)
{
System.out.print(leafNodeList.get(i) + " "); 
}
}


// a method that creates inorder traversal of a Binary Search Tree
// whose preorder traversal is given to us.
public int[] createInorder(int preorderArr[])
{

// computing the size of the preorderArr
int size = preorderArr.length;


// for storing the inorder traversal
int inorderArr[] = new int[size];


// copying the values in the array inorderArr[]
for(int i = 0; i < size; i++)
{
inorderArr[i] = preorderArr[i];     
}

// sorting to get the inorder
Arrays.sort(inorderArr);

return inorderArr;
}

public TreeNode createBST(int preorderArr[],int start1, int end1, int inorderArr[],int start2, int end2)
{
// handling the base case
if(start2 > end2)
{ 
return null;
}


// only one element is left, therefore create a node
// for it and return
if(start2 == end2)
{
return new TreeNode(inorderArr[end2]);
}


// creating the root node. The root node of the tree is  
// the first element of the array preorderArr[]
TreeNode root = new TreeNode(preorderArr[start1]);

// start looking for the root value in the array inorderArr
int j = start2;
for(; j <= end2; j++)
{
if(inorderArr[j] == preorderArr[start1])
{
// when the value is found
// terminate the loop using a break statement
break;
}
}

// values from start2 to j - 1 of the array inorderArr are the elements of the left subtree 
// values from j + 1 to end2 of the array inorderArr are the elements of the right subtree
// We need to separate the elements of the array preorderArr for the left and right subtrees 
// start1 + 1 to start1 + j - start2 are the elements of the left subtree
// start1 + j - start2 + 1 to end2 are the elements of the right subtree

// recursively constructing the Binary Search Tree using the preorerArr and inorderArr

// constructing the left subtree
root.left = createBST(preorderArr, start1 + 1, start1 + j - start2, inorderArr, start2, j - 1);

// constructing the right subtree
root.right = createBST(preorderArr, start1 + j - start2 + 1, end2, inorderArr, j + 1, end2);

// returning the root node
return root;
}


public void findLeafNodes(TreeNode rt, ArrayList<Integer> leafNodeList)
{
// handling the base case
if(rt == null)
{
return;
}

// if a node has its left and right child as null
// then it means that node is a leaf node, and we have
// to store the value of that leaf node in the leafNodeList
if(rt.left == null && rt.right == null)
{
leafNodeList.add(rt.val);

return;
}

// recursively finding the leaf nodes

// recursion towards the left child
findLeafNodes(rt.left, leafNodeList);

// recursion towards the right child
findLeafNodes(rt.right, leafNodeList);

}


// main method
public static void main(String argvs[]) 
{

// creating an object of the class DisplayLeafBST
DisplayLeafBST obj = new DisplayLeafBST();

// input 1
int preorderArr[] = {25, 20, 10, 5, 12, 22, 36, 30, 28, 40, 38, 48};
int size = preorderArr.length;


System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr[k] + " ");
}
System.out.println( "\n" );

// storing the inorder traversal
int inorderArr[] = obj.createInorder(preorderArr);

// invoking the method createBST() and storing the root node
TreeNode rt = obj.createBST(preorderArr, 0, size - 1, inorderArr, 0, size - 1);

// an array list for storing the leaf nodes
ArrayList<Integer> leafNodeList = new ArrayList<Integer>();
obj.findLeafNodes(rt, leafNodeList);
System.out.println("The leaf nodes are: " );
obj.displayLeafNodes(leafNodeList);

System.out.println( "\n" );

// input 2
int preorderArr1[] = {891, 326, 291, 531, 966};
size = preorderArr1.length;


System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr1[k] + " ");
}
System.out.println( "\n" );

// storing the inorder traversal
int inorderArr1[] = obj.createInorder(preorderArr1);

// invoking the method createBST() and storing the root node
rt = obj.createBST(preorderArr1, 0, size - 1, inorderArr1, 0, size - 1);

// an array list for storing the leaf nodes
leafNodeList = new ArrayList<Integer>();
obj.findLeafNodes(rt, leafNodeList);
System.out.println("The leaf nodes are: " );
obj.displayLeafNodes(leafNodeList);

}


}

Output:

For a Binary Search Tree that has the preorder traversal as: 
25 20 10 5 12 22 36 30 28 40 38 48 

The leaf nodes are: 
5 12 22 28 38 48 

For a Binary Search Tree that has the preorder traversal as: 
891 326 291 531 966 

The leaf nodes are: 
291 531 966

Complexity Analysis: The method createBST() consumes O(n2) time in order to construct the Binary Search Tree. Other methods are also taking time to produce their result. However, the maximum time is consumed by the method createBST(). Thus, the overall time complexity of the program is O(n2). Also, the program uses an auxiliary array for storing the leaf nodes as well as the inorder traversal. Thus, the space complexity of the program is O(n), where n is the total number of elements present in the array preorderArr[].

Optimization: If we observe, we find that, there is no need for method createBST() in the above program. Without creating the Binary Search Tree, we can easily find out the leaf nodes. Also, searching an element in the inorderArr[] does not require a linear search. It is because the inorderArr[] is sorted. Therefore, we can also binary search. It will reduce the time complexity from O(n) to O(log(n)). Observe the following program.

FileName: DisplayLeafBST1.java

// importing Arrays that are
// required in the program
import java.util.Arrays;


public class DisplayLeafBST1
{

// a method that finds the element ele in the array inorderArr and returns its index
public int binrySearch(int inorderArr[], int start1, int end1, int ele)
{
int midIndx = (start1 + end1) >> 1;

// element is found in the array inorderArr[]. Hence, return its index
if (inorderArr[midIndx] == ele)
{
return midIndx;
}

// the element is lesser than the middle element of the array inorderArr[]
// Hence, reduce the value of the middle index by 1
else if (inorderArr[midIndx] > ele)
{
return binrySearch(inorderArr, start1, midIndx - 1, ele);
}

// the element is more than the middle element of the array inorderArr[]
// Hence, increase the value of the middle index by 1
else
{
return binrySearch(inorderArr, midIndx + 1, end1, ele);
}
}

// a method that creates inorder traversal of a Binary Search Tree
// whose preorder traversal is given to us.
public int[] createInorder(int preorderArr[])
{

// computing the size of the preorderArr
int size = preorderArr.length;


// for storing the inorder traversal
int inorderArr[] = new int[size];


// copying the values in the array inorderArr[]
for(int i = 0; i < size; i++)
{
inorderArr[i] = preorderArr[i];     
}

// sorting to get the inorder
Arrays.sort(inorderArr);

return inorderArr;
}
static int indx = 0;

public void leafNodesRecursion(int preorderArr[], int inorderArr[], int start1, int end1, int size)
{
// If start1 == end1, hence there is no left or right subtree.
// So, it has to be a leaf Node. Therefore, display its value.
if(start1 == end1)
{
System.out.printf("%d ", inorderArr[start1]);
indx = indx + 1;
return;
}

// either start1 or end1 has gone beyond the size of the array. Hence, return.
if (start1 < 0 || start1 > end1 || end1 >= size)
{
return;
}

// looking for the index of the element present in preorderArr
// in the array inorderArr with the help of binary search.
int loccation = binrySearch(inorderArr, start1, end1, preorderArr[indx]);

// Increasing the index by 1
indx = indx + 1;

// looking in the left subtree.
leafNodesRecursion(preorderArr, inorderArr, start1, loccation - 1, size);

// looking in the right subtree.
leafNodesRecursion(preorderArr, inorderArr, loccation + 1, end1, size);
}



// main method
public static void main(String argvs[]) 
{

// creating an object of the class DisplayLeafBST1
DisplayLeafBST1 obj = new DisplayLeafBST1();

// input 1
int preorderArr[] = {25, 20, 10, 5, 12, 22, 36, 30, 28, 40, 38, 48};
int size = preorderArr.length;


System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr[k] + " ");
}
System.out.println( "\n" );

// storing the inorder traversal
int inorderArr[] = obj.createInorder(preorderArr);

System.out.println("The leaf nodes are: " );
obj.leafNodesRecursion(preorderArr, inorderArr, 0, size - 1, size);

System.out.println( "\n" );

// input 2
int preorderArr1[] = {891, 326, 291, 531, 966};
size = preorderArr1.length;

indx = 0; // resetting its value to zero for this input
System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr1[k] + " ");
}
System.out.println( "\n" );

// storing the inorder traversal
int inorderArr1[] = obj.createInorder(preorderArr1);

System.out.println("The leaf nodes are: " );
obj.leafNodesRecursion(preorderArr1, inorderArr1, 0, size - 1, size);


}


}

Output:

For a Binary Search Tree that has the preorder traversal as: 
25 20 10 5 12 22 36 30 28 40 38 48 

The leaf nodes are: 
5 12 22 28 38 48 

For a Binary Search Tree that has the preorder traversal as: 
891 326 291 531 966 

The leaf nodes are: 
291 531 966

Complexity Analysis: The method leafNodesRecursion() takes O(n) time. In each recursive call, we are invoking the method binrySearch() that takes O(log(n)) time. Thus, the overall time complexity of the program is O(n x log(n)), where n is the total number of elements present in the array preorderArr[]. The space complexity of the program remains the same as the previous program.

Let's do some more optimization to reduce the time complexity.

Approach: Using Stack

Using the stack and the property of the Binary Search Tree, the time complexity of the program can be reduced. First of all, we need to traverse the preorderArr[] with the help of two pointers, m and n. In the beginning, m = 0, and n = 1. When preorderArr[m] > preorderArr[n], then we can conclude that preorderArr[n] is the left part of preorderArr[m]. We know that preorder follows the pattern root -> left -> right. Therefore, the element preorderArr[m] is pushed into the stack.

For those nodes that are not implementing BST the rule, it is required to remove the elements from the stack until preorderArr[m] is greater than the top element of the stack and break the loop when it does not and then display the corresponding mth value.

FileName: DisplayLeafBST1.java

// importing Arrays that are
// required in the program
import java.util.Stack;


public class DisplayLeafBST2
{

// a method that finds out and prints the values of leaf nodes 
public void findPrintLeafNodes(int preorderArr[], int size)
{

Stack<Integer> s = new Stack<Integer> ();
for (int m = 0, n = 1; n < size; m++, n++)
{
boolean isFound = false;

// first of all, we traverse the left subtree of the Binary Search Tree.
// all the other nodes except the node of the minimum value in the 
// left subtree is pushed to the stack.
if(preorderArr[m] > preorderArr[n])
{
s.push(preorderArr[m]);
}

else
{
while (!s.isEmpty())
{
if (preorderArr[n] > s.peek())
{
// if we reach here, then it means that preorderArr[m] is a leaf node
s.pop();
isFound = true;
}
else
{
break;
}
}
}

if (isFound)
{
System.out.print(preorderArr[m] + " ");
}
}

// The rightmost element is always going to be a leaf node.
System.out.println(preorderArr[size - 1]);

}


// main method
public static void main(String argvs[]) 
{

// creating an object of the class DisplayLeafBST2
DisplayLeafBST2 obj = new DisplayLeafBST2();

// input 1
int preorderArr[] = {25, 20, 10, 5, 12, 22, 36, 30, 28, 40, 38, 48};
int size = preorderArr.length;


System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr[k] + " ");
}
System.out.println( "\n" );

System.out.println("The leaf nodes are: " );
obj.findPrintLeafNodes(preorderArr, size);

System.out.println( "\n" );

// input 2
int preorderArr1[] = {891, 326, 291, 531, 966};
size = preorderArr1.length;

System.out.println("For a Binary Search Tree that has the preorder traversal as: " );
for(int k = 0; k < size; k++)
{
System.out.print(preorderArr1[k] + " ");
}
System.out.println( "\n" );

System.out.println("The leaf nodes are: " );
obj.findPrintLeafNodes(preorderArr1, size);


}


}

Output:

For a Binary Search Tree that has the preorder traversal as: 
25 20 10 5 12 22 36 30 28 40 38 48 

The leaf nodes are: 
5 12 22 28 38 48


For a Binary Search Tree that has the preorder traversal as: 
891 326 291 531 966 

The leaf nodes are: 
291 531 966

Complexity Analysis: The maximum time a node is traversed is only two times. Therefore, the time complexity of the program is O(n). The program uses a stack for storing elements. Therefore, the space complexity remains the same as the previous programs.

Next TopicUnicodes for Operators in Java

← prev next →