Find all possible Binary Trees with given Inorder Traversal

Given an array that represents Inorder Traversal, the task is to find all possible Binary Trees with the given inorder traversal and print their preorder traversals.

Examples:

Input: inorder[] = {7, 5}
Output:
5 7
7 5

Input: inorder[] = {1, 2, 3}
Output:
1 2 3
1 3 2
2 1 3
3 1 2
3 2 1

Approach:

The idea is to generate all possible binary trees that can be formed from a given inorder traversal by recursively selecting each element as the root of the tree. Once a root is chosen, the remaining elements are divided into two subarrays—one for the left subtree and one for the right subtree. We then recursively generate all possible left and right subtrees for that root and combine them to form different binary trees.

Lets's say, for an inorder traversal [1, 2, 3]:

We treat each element (1, 2, or 3) as the root.
For root 2, the left subtree will be [1] and the right subtree will be [3]. Combine the trees formed from [1] and [3] with root 2 to generate one of the possible trees.
Repeat this for every element being the root and recursively generate subtrees.

Below is the implementation of the above approach:

C++

// C++ program to find binary tree with given 
// inorder traversal

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

class Node {
public:
    int data;
    Node* left;
    Node* right;

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

// Function to construct all possible binary trees 
// with given inorder traversal
vector<Node*> getTrees(const vector<int>& inorder, int start, int end) {
    vector<Node*> trees;

    // Base case: If start index is greater than end, 
  	// return empty tree (nullptr)
    if (start > end) {
        trees.push_back(nullptr);
        return trees;
    }

    // Iterate through all values in the array 
  	// and construct left and right subtrees
    for (int i = start; i <= end; ++i) {
        
        // Generate all left subtrees
        vector<Node*> leftTrees = getTrees(inorder, start, i - 1);

        // Generate all right subtrees
        vector<Node*> rightTrees = getTrees(inorder, i + 1, end);

        // Combine each left and right subtree with the current root
        for (Node* left : leftTrees) {
            for (Node* right : rightTrees) {
                
                // Make inorder[i] the root
                Node* root = new Node(inorder[i]); 
                root->left = left;
                root->right = right;

                // Add the constructed tree to the list of trees
                trees.push_back(root);
            }
        }
    }
    return trees;
}

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

int main() {

    vector<int> inorder = {1, 2, 3}; 
    int n = inorder.size();

    vector<Node*> trees = getTrees(inorder, 0, n - 1);

    for (int i = 0; i < trees.size(); ++i) {
        preorder(trees[i]);
        cout << "\n";
    }

    return 0;
}

Java

// Java program to find binary tree
// with given inorder traversal

import java.util.ArrayList;
import java.util.List;

class Node {
    int data;
    Node left, right;

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

class GfG {

    // Function to construct all possible binary trees with
    // given inorder traversal
    static List<Node> getTrees(List<Integer> inorder,
                                      int start, int end) {
        List<Node> trees = new ArrayList<>();

        // Base case: If start index is greater than end,
        // return empty tree (null)
        if (start > end) {
            trees.add(null);
            return trees;
        }

        // Iterate through all values in the array and
        // construct left and right subtrees
        for (int i = start; i <= end; ++i) {

            // Generate all left subtrees
            List<Node> leftTrees
                = getTrees(inorder, start, i - 1);

            // Generate all right subtrees
            List<Node> rightTrees
                = getTrees(inorder, i + 1, end);

            // Combine each left and right subtree with the
            // current root
            for (Node left : leftTrees) {
                for (Node right : rightTrees) {
                  
                  	// Make inorder[i] the root
                    Node root = new Node(inorder.get(i)); 
                    root.left = left;
                    root.right = right;
                    trees.add(root);
                }
            }
        }
        return trees;
    }

    // Function to print preorder traversal of the tree
    static void preorder(Node root) {
        if (root != null) {
            System.out.print(root.data + " ");
            preorder(root.left);
            preorder(root.right);
        }
    }

    public static void main(String[] args) {
      
        List<Integer> inorder = List.of(1, 2, 3);
        int n = inorder.size();

        List<Node> trees = getTrees(inorder, 0, n - 1);

        for (Node tree : trees) {
            preorder(tree);
            System.out.println();
        }
    }
}

Python

# Python program to find binary tree 
# with given inorder traversal

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

# Function to construct all possible binary trees 
# with given inorder traversal
def get_trees(inorder, start, end):
    trees = []

    # Base case: If start index is greater than end,
    # return empty tree (None)
    if start > end:
        trees.append(None)
        return trees

    # Iterate through all values in the array 
    # and construct left and right subtrees
    for i in range(start, end + 1):

        # Generate all left subtrees
        left_trees = get_trees(inorder, start, i - 1)

        # Generate all right subtrees
        right_trees = get_trees(inorder, i + 1, end)

        # Combine each left and right subtree with the current root
        for left in left_trees:
            for right in right_trees:
              	
                # Make inorder[i] the root
                root = Node(inorder[i])  
                root.left = left
                root.right = right
                trees.append(root)

    return trees

def preorder(root):
    if root:
        print(root.data, end=" ")
        preorder(root.left)
        preorder(root.right)

if __name__ == "__main__":
    inorder = [1, 2, 3]
    n = len(inorder)

    trees = get_trees(inorder, 0, n - 1)

    for tree in trees:
        preorder(tree)
        print()

// C# program to find binary tree with given inorder
// traversal

using System;
using System.Collections.Generic;

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

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

class GfG {

    // Function to construct all possible binary trees with
    // given inorder traversal
    static List<Node> GetTrees(List<int> inorder,
                                      int start, int end) {
        List<Node> trees = new List<Node>();

        // Base case: If start index is greater than end,
        // return empty tree (null)
        if (start > end) {
            trees.Add(null);
            return trees;
        }

        // Iterate through all values in the array and
        // construct left and right subtrees
        for (int i = start; i <= end; ++i) {

            // Generate all left subtrees
            List<Node> leftTrees
                = GetTrees(inorder, start, i - 1);

            // Generate all right subtrees
            List<Node> rightTrees
                = GetTrees(inorder, i + 1, end);

            // Combine each left and right subtree with the
            // current root
            foreach(Node left in leftTrees)
            {
                foreach(Node right in rightTrees)
                {
                  
                  	// Make inorder[i] the root
                    Node root = new Node(inorder[i]); 
                    root.left = left;
                    root.right = right;
                    trees.Add(root);
                }
            }
        }
        return trees;
    }

    static void Preorder(Node root) {
        if (root != null) {
            Console.Write(root.data + " ");
            Preorder(root.left);
            Preorder(root.right);
        }
    }

    static void Main(string[] args) {
        List<int> inorder = new List<int>{ 1, 2, 3 };
        int n = inorder.Count;

        List<Node> trees = GetTrees(inorder, 0, n - 1);

        foreach(Node tree in trees) {
            Preorder(tree);
            Console.WriteLine();
        }
    }
}

JavaScript

// JavaScript program to find binary tree with given inorder
// traversal

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

// Function to construct all possible binary trees with
// given inorder traversal
function getTrees(inorder, start, end) {
    let trees = [];

    // Base case: 
    // If start index is greater than end, return
    // empty tree (null)
    if (start > end) {
        trees.push(null);
        return trees;
    }

    // Iterate through all values in the array and construct
    // left and right subtrees
    for (let i = start; i <= end; ++i) {

        // Generate all left subtrees
        let leftTrees = getTrees(inorder, start, i - 1);

        // Generate all right subtrees
        let rightTrees = getTrees(inorder, i + 1, end);

        // Combine each left and right subtree with the
        // current root
        for (let left of leftTrees) {
            for (let right of rightTrees) {
            
            	// Make inorder[i] the root
                let root = new Node(inorder[i]); 
                root.left = left;
                root.right = right;
                trees.push(root);
            }
        }
    }

    return trees;
}

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

let inorder = [ 1, 2, 3 ];
let n = inorder.length;

let trees = getTrees(inorder, 0, n - 1);

for (let tree of trees) {
    preorder(tree);
    console.log("\n");
}

Output

Time Complexity: O(n * C_n), where C_n is the Catalan number
Auxiliary Space: O(C_n + n), for storing trees and the recursion stack.

Related articles:

Find all possible Binary Trees with given Inorder Traversal

Explore