Construct a Binary Tree from Postorder and Inorder

// C# program to construct tree using
// inorder and postorder traversals

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 find index of value in arr[start...end]
    // The function assumes that value is present in in[]
    static int Search(List<int> arr, int start, int end, int value) {
        int i;
        for (i = start; i <= end; i++) {
            if (arr[i] == value)
                break;
        }
        return i;
    }

    // Recursive function to construct binary of size n
    // from Inorder traversal in[] and Postorder traversal
    // post[]. Initial values of inStrt and inEnd should
    // be 0 and n -1.
    static Node BuildUtil(List<int> inorder, List<int> postorder, 
                   int inStart, int inEnd, ref int pIndex) {
        if (inStart > inEnd)
            return null;

        // Pick current node from Postorder traversal using
        // postIndex and decrement postIndex
        Node node = new Node(postorder[pIndex]);
        pIndex--;

        // If this node has no children then return
        if (inStart == inEnd)
            return node;

        // Else find the index of this node in Inorder traversal
        int inIndex = Search(inorder, inStart, inEnd, node.data);

        // Using index in Inorder traversal, construct left and
        // right subtrees
        node.right = BuildUtil(inorder, postorder,
                               inIndex + 1, inEnd, ref pIndex);
        node.left = BuildUtil(inorder, postorder, 
                              inStart, inIndex - 1, ref pIndex);

        return node;
    }

    // This function mainly initializes index of root
    // and calls BuildUtil()
    static Node buildTree(List<int> inorder, List<int> postorder) {
        int n = inorder.Count;
        int pIndex = n - 1;
        return BuildUtil(inorder, postorder, 0, n - 1, ref pIndex);
    }

    // Print the preorder of a binary tree
    static void Print(Node curr) {
        if (curr == null)
            return;
        Console.Write(curr.data + " ");
        Print(curr.left);
        Print(curr.right);
    }

    static void Main() {
        List<int> inorder = new List<int> { 4, 8, 2, 5, 1, 6, 3, 7 };
        List<int> postorder = new List<int> { 8, 4, 5, 2, 6, 7, 3, 1 };

        Node root = buildTree(inorder, postorder);
        Print(root);
    }
}

// C# program to construct a binary tree 
// using inorder and postorder traversals
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 recursively build the tree from
    // inorder and postorder traversals
    static Node BuildUtil(List<int> inorder, List<int> postorder, int inStrt, 
                          int inEnd, ref int pIndex, Dictionary<int, int> mp) {
      
        // if start index exceeds end index, return null
        if (inStrt > inEnd)
            return null;

        // Get the current node value from postorder
        // traversal using pIndex and decrement pIndex
        int curr = postorder[pIndex];
        Node node = new Node(curr);
        pIndex--;

        // If the current node has no children
        // (inStrt == inEnd), return the node
        if (inStrt == inEnd)
            return node;

        // Find the index of the current node's
        // value in the inorder traversal
        int iIndex = mp[curr];

        // Recursively build the right and left subtrees
        node.right = BuildUtil(inorder, postorder, iIndex + 1, inEnd, ref pIndex, mp);
        node.left = BuildUtil(inorder, postorder, inStrt, iIndex - 1, ref pIndex, mp);

        return node;
    }

    // Main function to build the binary tree
    // from inorder and postorder vectors
    static Node buildTree(List<int> inorder, List<int> postorder) {
      
        // Create a dictionary to store the
        // indexes of inorder elements for quick lookup
        Dictionary<int, int> mp = new Dictionary<int, int>();
        for (int i = 0; i < inorder.Count; i++)
            mp[inorder[i]] = i;

        // Initialize postorder index as the last element
        int postIndex = postorder.Count - 1;

        // Call the recursive utility function
      	// to build the tree
        return BuildUtil(inorder, postorder, 0,
                         inorder.Count - 1, ref postIndex, mp);
    }

    // Function to print preorder traversal of the tree
    static void Print(Node curr) {
        if (curr == null)
            return;
        Console.Write(curr.data + " ");
        Print(curr.left);
        Print(curr.right);
    }

    static void Main(string[] args) {
      
        List<int> inorder = new List<int>{ 4, 8, 2, 5, 1, 6, 3, 7 };
        List<int> postorder = new List<int>{ 8, 4, 5, 2, 6, 7, 3, 1 };

        Node root = buildTree(inorder, postorder);
        Print(root);
    }
}