Algorithm to Solve Sudoku | Sudoku Solver

Construct Special Binary Tree from given Inorder traversal

Last Updated : 01 Aug, 2022

Given Inorder Traversal of a Special Binary Tree in which the key of every node is greater than keys in left and right children, construct the Binary Tree and return root.

Examples:

Input: inorder[] = {5, 10, 40, 30, 28}
Output: root of following tree
         40
       /   \
      10     30
     /         \
    5          28 

Input: inorder[] = {1, 5, 10, 40, 30, 
                    15, 28, 20}
Output: root of following tree
          40
        /   \
       10     30
      /         \
     5          28
    /          /  \
   1         15    20

The idea used in Construction of Tree from given Inorder and Preorder traversals can be used here. Let the given array is {1, 5, 10, 40, 30, 15, 28, 20}. The maximum element in the given array must be root. The elements on the left side of the maximum element are in the left subtree and the elements on the right side are in the right subtree.

         40
      /       \  
   {1,5,10}   {30,15,28,20}

We recursively follow the above step for left and right subtrees, and finally, get the following tree.

          40
        /   \
       10     30
      /         \
     5          28
    /          /  \
   1         15    20

Algorithm: buildTree()

Find index of the maximum element in array. The maximum element must be root of Binary Tree.

Create a new tree node ‘root’ with the data as the maximum value found in step 1.

Call buildTree for elements before the maximum element and make the built tree as left subtree of ‘root’.

Call buildTree for elements after the maximum element and make the built tree as right subtree of ‘root’.

return ‘root’.

Below is the implementation of the above approach:

C++

/* C++ program to construct tree
from inorder traversal */
#include <bits/stdc++.h>
using namespace std;
 
/* A binary tree node has data, 
pointer to left child and 
a pointer to right child */
class node 
{ 
    public:
    int data; 
    node* left; 
    node* right; 
}; 
 
/* Prototypes of a utility function to get the maximum 
value in inorder[start..end] */
int max(int inorder[], int strt, int end); 
 
/* A utility function to allocate memory for a node */
node* newNode(int data); 
 
/* Recursive function to construct binary of size len from 
Inorder traversal inorder[]. Initial values of start and end 
should be 0 and len -1. */
node* buildTree (int inorder[], int start, int end) 
{ 
    if (start > end) 
        return NULL; 
 
    /* Find index of the maximum element from Binary Tree */
    int i = max (inorder, start, end); 
 
    /* Pick the maximum value and make it root */
    node *root = newNode(inorder[i]); 
 
    /* If this is the only element in inorder[start..end], 
    then return it */
    if (start == end) 
        return root; 
 
    /* Using index in Inorder traversal, construct left and 
    right subtress */
    root->left = buildTree (inorder, start, i - 1); 
    root->right = buildTree (inorder, i + 1, end); 
 
    return root; 
} 
 
/* UTILITY FUNCTIONS */
/* Function to find index of the maximum value in arr[start...end] */
int max (int arr[], int strt, int end) 
{ 
    int i, max = arr[strt], maxind = strt; 
    for(i = strt + 1; i <= end; i++) 
    { 
        if(arr[i] > max) 
        { 
            max = arr[i]; 
            maxind = i; 
        } 
    } 
    return maxind; 
} 
 
/* Helper function that allocates a new node with the 
given data and NULL left and right pointers. */
node* newNode (int data) 
{ 
    node* Node = new node();
    Node->data = data; 
    Node->left = NULL; 
    Node->right = NULL; 
 
    return Node; 
} 
 
/* This function is here just to test buildTree() */
void printInorder (node* node) 
{ 
    if (node == NULL) 
        return; 
 
    /* first recur on left child */
    printInorder (node->left); 
 
    /* then print the data of node */
    cout<<node->data<<" "; 
 
    /* now recur on right child */
    printInorder (node->right); 
} 
 
/* Driver code*/
int main() 
{ 
    /* Assume that inorder traversal of following tree is given 
        40 
        / \ 
        10 30 
        /     \ 
        5     28 */
 
    int inorder[] = {5, 10, 40, 30, 28}; 
    int len = sizeof(inorder)/sizeof(inorder[0]); 
    node *root = buildTree(inorder, 0, len - 1); 
 
    /* Let us test the built tree by printing Inorder traversal */
    cout << "Inorder traversal of the constructed tree is \n"; 
    printInorder(root); 
    return 0; 
} 
 
// This is code is contributed by rathbhupendra

C

/* program to construct tree from inorder traversal */
#include<stdio.h>
#include<stdlib.h>
 
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
struct node
{
    int data;
    struct node* left;
    struct node* right;
};
 
/* Prototypes of a utility function to get the maximum
   value in inorder[start..end] */
int max(int inorder[], int strt, int end);
 
/* A utility function to allocate memory for a node */
struct node* newNode(int data);
 
/* Recursive function to construct binary of size len from
   Inorder traversal inorder[]. Initial values of start and end
   should be 0 and len -1.  */
struct node* buildTree (int inorder[], int start, int end)
{
    if (start > end)
        return NULL;
 
    /* Find index of the maximum element from Binary Tree */
    int i = max (inorder, start, end);
 
    /* Pick the maximum value and make it root */
    struct node *root = newNode(inorder[i]);
 
    /* If this is the only element in inorder[start..end],
       then return it */
    if (start == end)
        return root;
 
    /* Using index in Inorder traversal, construct left and
       right subtress */
    root->left  = buildTree (inorder, start, i-1);
    root->right = buildTree (inorder, i+1, end);
 
    return root;
}
 
/* UTILITY FUNCTIONS */
/* Function to find index of the maximum value in arr[start...end] */
int max (int arr[], int strt, int end)
{
    int i, max = arr[strt], maxind = strt;
    for(i = strt+1; i <= end; i++)
    {
        if(arr[i] > max)
        {
            max = arr[i];
            maxind = i;
        }
    }
    return maxind;
}
 
/* Helper function that allocates a new node with the
   given data and NULL left and right pointers. */
struct node* newNode (int data)
{
    struct node* node = (struct node*)malloc(sizeof(struct node));
    node->data = data;
    node->left = NULL;
    node->right = NULL;
 
    return node;
}
 
/* This function is here just to test buildTree() */
void printInorder (struct node* node)
{
    if (node == NULL)
        return;
 
    /* first recur on left child */
    printInorder (node->left);
 
    /* then print the data of node */
    printf("%d ", node->data);
 
    /* now recur on right child */
    printInorder (node->right);
}
 
/* Driver program to test above functions */
int main()
{
   /* Assume that inorder traversal of following tree is given
         40
       /   \
      10     30
     /         \
    5          28 */
 
    int inorder[] = {5, 10, 40, 30, 28};
    int len = sizeof(inorder)/sizeof(inorder[0]);
    struct node *root = buildTree(inorder, 0, len - 1);
 
    /* Let us test the built tree by printing Inorder traversal */
    printf("\n Inorder traversal of the constructed tree is \n");
    printInorder(root);
    return 0;
}

Java

// Java program to construct tree from inorder traversal
  
/* A binary tree node has data, pointer to left child
   and a pointer to right child */
class Node 
{
    int data;
    Node left, right;
  
    Node(int item) 
    {
        data = item;
        left = right = null;
    }
}
  
class BinaryTree 
{
    Node root;
  
    /* Recursive function to construct binary of size len from
       Inorder traversal inorder[]. Initial values of start and end
       should be 0 and len -1.  */
    Node buildTree(int inorder[], int start, int end, Node node) 
    {
        if (start > end)
            return null;
  
        /* Find index of the maximum element from Binary Tree */
        int i = max(inorder, start, end);
  
        /* Pick the maximum value and make it root */
        node = new Node(inorder[i]);
  
        /* If this is the only element in inorder[start..end],
         then return it */
        if (start == end)
            return node;
  
        /* Using index in Inorder traversal, construct left and
         right subtress */
        node.left = buildTree(inorder, start, i - 1, node.left);
        node.right = buildTree(inorder, i + 1, end, node.right);
  
        return node;
    }
  
    /* UTILITY FUNCTIONS */
     
    /* Function to find index of the maximum value in arr[start...end] */
    int max(int arr[], int strt, int end) 
    {
        int i, max = arr[strt], maxind = strt;
        for (i = strt + 1; i <= end; i++) 
        {
            if (arr[i] > max) 
            {
                max = arr[i];
                maxind = i;
            }
        }
        return maxind;
    }
  
    /* This function is here just to test buildTree() */
    void printInorder(Node node) 
    {
        if (node == null)
            return;
  
        /* first recur on left child */
        printInorder(node.left);
  
        /* then print the data of node */
        System.out.print(node.data + " ");
  
        /* now recur on right child */
        printInorder(node.right);
    }
  
    public static void main(String args[]) 
    {
        BinaryTree tree = new BinaryTree();
         
        /* Assume that inorder traversal of following tree is given
             40
            /   \
          10     30
         /         \
        5          28 */
        int inorder[] = new int[]{5, 10, 40, 30, 28};
        int len = inorder.length;
        Node mynode = tree.buildTree(inorder, 0, len - 1, tree.root);
  
        /* Let us test the built tree by printing Inorder traversal */
        System.out.println("Inorder traversal of the constructed tree is ");
        tree.printInorder(mynode);
    }
}
  
// This code has been contributed by Mayank Jaiswal

Python3

# Python3 program to construct tree from
# inorder traversal 
 
# Helper class that allocates a new node 
# with the given data and None left and
# right pointers. 
class newNode:
    def __init__(self, data):
        self.data = data 
        self.left = None
        self.right = None
 
# Prototypes of a utility function to get 
# the maximum value in inorder[start..end] 
 
# Recursive function to construct binary of 
# size len from Inorder traversal inorder[]. 
# Initial values of start and end should be 
# 0 and len -1. 
def buildTree (inorder, start, end):
    if start > end:
        return None
 
    # Find index of the maximum element 
    # from Binary Tree 
    i = Max (inorder, start, end) 
 
    # Pick the maximum value and make it root 
    root = newNode(inorder[i]) 
 
    # If this is the only element in 
    # inorder[start..end], then return it 
    if start == end: 
        return root 
 
    # Using index in Inorder traversal, 
    # construct left and right subtress 
    root.left = buildTree (inorder, start, i - 1) 
    root.right = buildTree (inorder, i + 1, end) 
 
    return root
 
# UTILITY FUNCTIONS 
 
# Function to find index of the maximum 
# value in arr[start...end] 
def Max(arr, strt, end):
    i, Max = 0, arr[strt]
    maxind = strt
    for i in range(strt + 1, end + 1):
        if arr[i] > Max:
            Max = arr[i] 
            maxind = i
    return maxind
 
# This function is here just to test buildTree() 
def printInorder (node):
    if node == None: 
        return
 
    # first recur on left child 
    printInorder (node.left) 
 
    # then print the data of node 
    print(node.data, end = " ")
 
    # now recur on right child 
    printInorder (node.right)
 
# Driver Code
if __name__ == '__main__':
     
    # Assume that inorder traversal of 
    # following tree is given 
    #     40 
    # / \ 
    # 10     30 
    # /         \ 
    #5         28 
 
    inorder = [5, 10, 40, 30, 28]
    Len = len(inorder) 
    root = buildTree(inorder, 0, Len - 1) 
 
    # Let us test the built tree by 
    # printing Inorder traversal 
    print("Inorder traversal of the", 
              "constructed tree is ") 
    printInorder(root)
     
# This code is contributed by PranchalK

C#

// C# program to construct tree 
// from inorder traversal 
using System;
 
/* A binary tree node has data, 
pointer to left child and a pointer
to right child */
public class Node
{
    public int data;
    public Node left, right;
 
    public Node(int item)
    {
        data = item;
        left = right = null;
    }
}
 
class GFG
{
public Node root;
 
/* Recursive function to construct binary 
of size len from Inorder traversal inorder[]. 
Initial values of start and end should be 0 
and len -1. */
public virtual Node buildTree(int[] inorder, int start,
                              int end, Node node)
{
    if (start > end)
    {
        return null;
    }
 
    /* Find index of the maximum 
    element from Binary Tree */
    int i = max(inorder, start, end);
 
    /* Pick the maximum value and
    make it root */
    node = new Node(inorder[i]);
 
    /* If this is the only element in 
    inorder[start..end], then return it */
    if (start == end)
    {
        return node;
    }
 
    /* Using index in Inorder traversal, 
    construct left and right subtress */
    node.left = buildTree(inorder, start,
                          i - 1, node.left);
    node.right = buildTree(inorder, i + 1, 
                           end, node.right);
 
    return node;
}
 
/* UTILITY FUNCTIONS */
 
/* Function to find index of the
maximum value in arr[start...end] */
public virtual int max(int[] arr, 
                       int strt, int end)
{
    int i, max = arr[strt], maxind = strt;
    for (i = strt + 1; i <= end; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
            maxind = i;
        }
    }
    return maxind;
}
 
/* This function is here just 
   to test buildTree() */
public virtual void printInorder(Node node)
{
    if (node == null)
    {
        return;
    }
 
    /* first recur on left child */
    printInorder(node.left);
 
    /* then print the data of node */
    Console.Write(node.data + " ");
 
    /* now recur on right child */
    printInorder(node.right);
}
 
// Driver Code
public static void Main(string[] args)
{
    GFG tree = new GFG();
 
    /* Assume that inorder traversal 
       of following tree is given 
        40 
        / \ 
    10     30 
    /         \ 
    5         28 */
    int[] inorder = new int[]{5, 10, 40, 30, 28};
    int len = inorder.Length;
    Node mynode = tree.buildTree(inorder, 0, 
                                 len - 1, tree.root);
 
    /* Let us test the built tree by 
       printing Inorder traversal */
    Console.WriteLine("Inorder traversal of " + 
                   "the constructed tree is ");
    tree.printInorder(mynode);
}
}
 
// This code is contributed by Shrikant13

Javascript

<script>
  
// JavaScript program to construct tree 
// from inorder traversal 
 
/* A binary tree node has data, 
pointer to left child and a pointer
to right child */
class Node
{
    constructor(item)
    {
        this.data = item;
        this.left = null;
        this.right = null;
    }
}
 
var root = null;
 
/* Recursive function to construct binary 
of size len from Inorder traversal inorder[]. 
Initial values of start and end should be 0 
and len -1. */
function buildTree(inorder, start, end, node)
{
    if (start > end)
    {
        return null;
    }
 
    /* Find index of the maximum 
    element from Binary Tree */
    var i = max(inorder, start, end);
 
    /* Pick the maximum value and
    make it root */
    node = new Node(inorder[i]);
 
    /* If this is the only element in 
    inorder[start..end], then return it */
    if (start == end)
    {
        return node;
    }
 
    /* Using index in Inorder traversal, 
    construct left and right subtress */
    node.left = buildTree(inorder, start,
                          i - 1, node.left);
    node.right = buildTree(inorder, i + 1, 
                           end, node.right);
 
    return node;
}
 
/* UTILITY FUNCTIONS */
 
/* Function to find index of the
maximum value in arr[start...end] */
function max(arr, strt, end)
{
    var i, maxi = arr[strt], maxind = strt;
    for (i = strt + 1; i <= end; i++)
    {
        if (arr[i] > maxi)
        {
            maxi = arr[i];
            maxind = i;
        }
    }
    return maxind;
}
 
/* This function is here just 
   to test buildTree() */
function printInorder(node)
{
    if (node == null)
    {
        return;
    }
 
    /* first recur on left child */
    printInorder(node.left);
 
    /* then print the data of node */
    document.write(node.data + " ");
 
    /* now recur on right child */
    printInorder(node.right);
}
 
// Driver Code
 
/* Assume that inorder traversal 
   of following tree is given 
    40 
    / \ 
10     30 
/         \ 
5         28 */
var inorder = [5, 10, 40, 30, 28];
var len = inorder.length;
var mynode = buildTree(inorder, 0, len - 1, root);
/* Let us test the built tree by 
   printing Inorder traversal */
document.write("Inorder traversal of " + 
               "the constructed tree is <br>");
printInorder(mynode);
 
 
</script>

Output

Inorder traversal of the constructed tree is 
5 10 40 30 28

Time Complexity: O(n^2)
Auxiliary Space: O(n), The extra space used is due to the recursion call stack.

Algorithm to Solve Sudoku | Sudoku Solver

kartik

Improve

Article Tags :

DSA
Tree

Practice Tags :

Tree

Similar Reads

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 no

Construct Tree from given Inorder and Preorder traversals

Given in-order and pre-order traversals of a Binary Tree, the task is to construct the Binary Tree and return its root. Example: Input: inorder[] = [3, 1, 4, 0, 5, 2], preorder[] = [0, 1, 3, 4, 2, 5]Output: [0, 1, 2, 3, 4, 5]Explanation: The tree will look like: Table of Content [Naive Approach] Usi

Construct Full Binary Tree from given preorder and postorder traversals

Given two arrays that represent preorder and postorder traversals of a full binary tree, construct the binary tree. Full Binary Tree is a binary tree where every node has either 0 or 2 children. Examples of Full Trees. Input: pre[] = [1, 2, 4, 8, 9, 5, 3, 6, 7] , post[] = [8, 9, 4, 5, 2, 6, 7, 3, 1]

Construct a Binary Search Tree from given postorder

Given postorder traversal of a binary search tree, construct the BST. For example, if the given traversal is {1, 7, 5, 50, 40, 10}, then following tree should be constructed and root of the tree should be returned. 10 / \ 5 40 / \ \ 1 7 50Recommended PracticeConstruct BST from PostorderTry It! Metho

Construct a Perfect Binary Tree from Preorder Traversal

Given an array pre[], representing the Preorder traversal of a Perfect Binary Tree consisting of N nodes, the task is to construct a Perfect Binary Tree from the given Preorder Traversal and return the root of the tree. Examples: Input: pre[] = {1, 2, 4, 5, 3, 6, 7}Output: 1 / \ / \ 2 3 / \ / \ / \

Construct a Complete N-ary Tree from given Postorder Traversal

Given an array arr[] of size M that contains the post-order traversal of a complete N-ary tree, the task is to generate the N-ary tree and print its preorder traversal. A complete tree is a tree where all the levels of the tree are completely filled, except may be for the last level but the nodes in

Construct the full k-ary tree from its preorder traversal

Given an array that contains the preorder traversal of the full k-ary tree, the task is to construct the full k-ary tree and return its postorder traversal. A full k-ary tree is a tree where each node has either 0 or k children. Examples: Input: pre[] = {1, 2, 5, 6, 7, 3, 8, 9, 10, 4}, k = 3 Output:

Construct BST from its given level order traversal | Set-2

Construct the BST (Binary Search Tree) from its given level order traversal. Examples: Input : {7, 4, 12, 3, 6, 8, 1, 5, 10} Output : BST: 7 / \ 4 12 / \ / 3 6 8 / / \ 1 5 10Recommended: Please solve it on "PRACTICE" first, before moving on to the solution. Approach : The idea is to make a struct el

Construct BST from given preorder traversal using Stack

Given preorder traversal of a binary search tree, construct the BST.For example, if the given traversal is {10, 5, 1, 7, 40, 50}, then the output should be root of following tree. 10 / \ 5 40 / \ \ 1 7 50 We have discussed O(n^2) and O(n) recursive solutions in the previous post. Following is a stac

Construct a Binary Tree from Postorder and Inorder

Given inorder and postorder traversals of a binary tree(having n nodes) in the arrays inorder[] and postorder[] respectively. The task is to construct a unique binary tree from these traversals and return the preorder traversal of the constructed tree. Examples: Input: inorder[] = [2, 1, 3], postord