Construct a special tree from given preorder traversal

Given an array pre[] that represents the Preorder traversal of a special binary tree where every node has either 0 or 2 children. One more array preLN[] is given which has only two possible values ‘L’ and ‘N’. The value ‘L’ in preLN[] indicates that the corresponding node in Binary Tree is a leaf node and the value ‘N’ indicates that the corresponding node is a non-leaf node. The task is to construct the tree from the given two arrays.

Example:

Input: pre[] = {10, 30, 20, 5, 15}, preLN[] = {'N', 'N', 'L', 'L', 'L'}
Output:

Try It Yourself

Table of Content

[Expected Approach] Using Pre-Order Traversal - O(n) Time and O(h) Space
[Alternate Approach] Using Stack - O(n) Time and O(h) Space

[Expected Approach] Using Pre-Order Traversal - O(n) Time and O(h) Space

The first element in pre[] will always be root. So we can easily figure out the root. If the left subtree is empty, the right subtree must also be empty, and the preLN[] entry for root must be ‘L’. We can simply create a node and return it. If the left and right subtrees are not empty, then recursively call for left and right subtrees and link the returned nodes to root.

C++

// C++ program to construct tree
// from preorder traversal
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *left, *right;
    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// Recursive function to construct the tree
Node* constructTreeRecur(int &index, vector<int>& pre, 
                         vector<char>& preLN) {
    
    Node* root = new Node(pre[index++]);
    
    // If the current node is leaf node,
    // then return the node.
    if (preLN[index-1] == 'L')
        return root;
    
    // Recursively create the left and right subtree.    
    root->left = constructTreeRecur(index, pre, preLN);
    root->right = constructTreeRecur(index, pre, preLN);
    
    return root;
}

Node* constructTree(int n, vector<int>& pre, vector<char>& preLN) {
    
    // base case
    if (n == 0) return nullptr;
    
    int index = 0;
    return constructTreeRecur(index, pre, preLN);
}

void inorder(Node* root) {
    if (root == nullptr) return;
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {

    vector<int> pre = {10, 30, 20, 5, 15};
    vector<char> preLN = {'N', 'N', 'L', 'L', 'L'};
    int n = 5;
    
    Node* root = constructTree(n, pre, preLN);
    inorder(root);
    return 0;
}

Java

// Java program to construct tree
// from preorder traversal
import java.util.ArrayList;

class Node {
    int data;
    Node left, right;

    Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Recursive function to construct the tree
    static Node constructTreeRecur(int[] index, 
	ArrayList<Integer> pre, ArrayList<Character> preLN) {
     
        Node root = new Node(pre.get(index[0]++));
        
        // If the current node is leaf node,
        // then return the node.
        if (preLN.get(index[0] - 1) == 'L')
            return root;
        
        // Recursively create the left and right subtree.
        root.left = constructTreeRecur(index, pre, preLN);
        root.right = constructTreeRecur(index, pre, preLN);
        
        return root;
    }
    
    // Main function to construct the tree
    static Node constructTree(int n, 
	ArrayList<Integer> pre, ArrayList<Character> preLN) {
        
        // base case
        if (n == 0) return null;
        
        int[] index = {0};
        return constructTreeRecur(index, pre, preLN);
    }
    
    static void inorder(Node root) {
        if (root == null) return;
        inorder(root.left);
        System.out.print(root.data + " ");
        inorder(root.right);
    }

    public static void main(String[] args) {
        ArrayList<Integer> pre = new ArrayList<>();
        pre.add(10); pre.add(30); pre.add(20); pre.add(5); pre.add(15);
        
        ArrayList<Character> preLN = new ArrayList<>();
        preLN.add('N'); 
      	preLN.add('N'); 
     	preLN.add('L'); 
     	preLN.add('L');
      	preLN.add('L');
        
        Node root = constructTree(pre.size(), pre, preLN);
        inorder(root);
    }
}

Python

# Python program to construct tree
# from preorder traversal

class Node:
    def __init__(self, x):
        self.data = x
        self.left = None
        self.right = None

# Recursive function to construct the tree
def constructTreeRecur(index, pre, preLN):
    
    root = Node(pre[index[0]])
    index[0] += 1
    
    # If the current node is leaf node,
    # then return the node.
    if preLN[index[0] - 1] == 'L':
        return root
    
    # Recursively create the left and right subtree.
    root.left = constructTreeRecur(index, pre, preLN)
    root.right = constructTreeRecur(index, pre, preLN)

    return root

def constructTree(n, pre, preLN):
    
    # base case
    if n == 0:
        return None
    
    index = [0]
    return constructTreeRecur(index, pre, preLN)

def inorder(root):
    if root is None:
        return
    inorder(root.left)
    print(root.data, end=" ")
    inorder(root.right)

if __name__ == '__main__':
    pre = [10, 30, 20, 5, 15]
    preLN = ['N', 'N', 'L', 'L', 'L']
    
    root = constructTree(len(pre), pre, preLN)
    inorder(root)

// C# program to construct tree
// from preorder traversal
using System;
using System.Collections.Generic;

class Node {
    public int data;
    public Node left, right;

    public Node(int x) {
        data = x;
        left = null;
        right = null;
    }
}

class GfG {
    
    // Recursive function to construct the tree
    static Node ConstructTreeRecur(ref int index,
						List<int> pre, List<char> preLN) {
        

        Node root = new Node(pre[index++]);
        
        // If the current node is leaf node,
        // then return the node.
        if (preLN[index - 1] == 'L')
            return root;
        
        // Recursively create the left and right subtree.
        root.left = ConstructTreeRecur(ref index, pre, preLN);
        root.right = ConstructTreeRecur(ref index, pre, preLN);

        return root;
    }
    
    static Node ConstructTree(int n, List<int> pre, 
                              List<char> preLN) {
        
        // base case
        if (n == 0) return null;
        
        int index = 0;
        return ConstructTreeRecur(ref index, pre, preLN);
    }
    
    static void Inorder(Node root) {
        if (root == null) return;
        Inorder(root.left);
        Console.Write(root.data + " ");
        Inorder(root.right);
    }

    static void Main(string[] args) {
        List<int> pre = new List<int>{ 10, 30, 20, 5, 15 };
        List<char> preLN = new List<char>{ 'N', 'N', 'L', 'L', 'L' };
        
        Node root = ConstructTree(pre.Count, pre, preLN);
        Inorder(root);
    }
}

JavaScript

// JavaScript program to construct tree
// from preorder traversal

class Node {
    constructor(x) {
        this.data = x;
        this.left = null;
        this.right = null;
    }
}

// Recursive function to construct the tree
function constructTreeRecur(index, pre, preLN) {

    let root = new Node(pre[index[0]++]);
    
    // If the current node is leaf node,
    // then return the node.
    if (preLN[index[0] - 1] === 'L') return root;
    
    // Recursively create the left and right subtree.
    root.left = constructTreeRecur(index, pre, preLN);
    root.right = constructTreeRecur(index, pre, preLN);
    
    return root;
}

function constructTree(n, pre, preLN) {
    
    // base case
    if (n === 0) return null;
    
    let index = [0];
    return constructTreeRecur(index, pre, preLN);
}

function inorder(root) {
    if (root === null) return;
    inorder(root.left);
    console.log(root.data + " ");
    inorder(root.right);
}

let pre = [10, 30, 20, 5, 15];
let preLN = ['N', 'N', 'L', 'L', 'L'];

let root = constructTree(pre.length, pre, preLN);
inorder(root);

Output

20 30 5 10 15

[Alternate Approach] Using Stack - O(n) Time and O(h) Space

The idea is to use a stack to implement pre-order traversal and construct the binary tree and return the root node.

Step by step implementation:

As the Pre-order Traversal is given, so we first create the root node and insert it into an empty stack.
Traverse the given pre-order traversal.
1. Create the node corresponding to the current value.
2. Check the top node in the stack:
  - If left of top node is null, then set the current node as left of top node.
  - Else, right of top node is null, then set the current node as right of top node and pop the top node.
3. If the present node is not a leaf node, push node into the stack.
Return the root of the constructed tree.

C++

// C++ program to construct tree
// from preorder traversal
#include <bits/stdc++.h>
using namespace std;

class Node {
  public:
    int data;
    Node *left, *right;
    Node(int x) {
        data = x;
        left = nullptr;
        right = nullptr;
    }
};

// function to construct the tree
Node* constructTree(int n, vector<int>& pre, 
                    vector<char>& preLN) {
    
    // base case
    if (n == 0) return nullptr;
    
    stack<Node*> st;
    Node* root = new Node(pre[0]);
    
    // Checking if root is not leaf node
    if (preLN[0] != 'L')
        st.push(root);

    // Iterating over the given node values
    for (int i = 1; i < n; i++) {
        Node* curr = new Node(pre[i]);

        // Checking if the left position is 
      	// NULL or not
        if (!st.top()->left) {
            st.top()->left = curr;
        }

        // Checking if the right position 
      	// is NULL or not
        else if (!st.top()->right) {
            st.top()->right = curr;
            st.pop();
        }
        
        // If current node is internal node,
        // then push it to stack.
        if (preLN[i] != 'L')
            st.push(curr);
    }

    return root;
}

void inorder(Node* root) {
    if (root == nullptr) return;
    inorder(root->left);
    cout << root->data << " ";
    inorder(root->right);
}

int main() {

    vector<int> pre = {10, 30, 20, 5, 15};
    vector<char> preLN = {'N', 'N', 'L', 'L', 'L'};
    int n = 5;
    
    Node* root = constructTree(n, pre, preLN);
    inorder(root);
    return 0;
}