Construct Binary Tree from given Parent Array representation

// Java program to construct a binary tree from parent array
 
// A binary tree node
class Node 
{
    int key;
    Node left, right;
 
    public Node(int key) 
    {
        this.key = key;
        left = right = null;
    }
}
 
class BinaryTree 
{
    Node root;
 
    // Creates a node with key as 'i'.  If i is root, then it changes
    // root.  If parent of i is not created, then it creates parent first
    void createNode(int parent[], int i, Node created[]) 
    {
        // If this node is already created
        if (created[i] != null)
            return;
 
        // Create a new node and set created[i]
        created[i] = new Node(i);
 
        // If 'i' is root, change root pointer and return
        if (parent[i] == -1) 
        {
            root = created[i];
            return;
        }
 
        // If parent is not created, then create parent first
        if (created[parent[i]] == null)
            createNode(parent, parent[i], created);
 
        // Find parent pointer
        Node p = created[parent[i]];
 
        // If this is first child of parent
        if (p.left == null)
            p.left = created[i];
        else // If second child
         
            p.right = created[i];
    }
 
    /* Creates tree from parent[0..n-1] and returns root of 
       the created tree */
    Node createTree(int parent[], int n) 
    {    
        // Create an array created[] to keep track
        // of created nodes, initialize all entries
        // as NULL
        Node[] created = new Node[n];
        for (int i = 0; i < n; i++) 
            created[i] = null;
 
        for (int i = 0; i < n; i++)
            createNode(parent, i, created);
 
        return root;
    }
 
    //For adding new line in a program
    void newLine() 
    {
        System.out.println("");
    }
 
    // Utility function to do inorder traversal
    void inorder(Node node) 
    {
        if (node != null) 
        {
            inorder(node.left);
            System.out.print(node.key + " ");
            inorder(node.right);
        }
    }
 
    // Driver method
    public static void main(String[] args) 
    {
 
        BinaryTree tree = new BinaryTree();
        int parent[] = new int[]{-1, 0, 0, 1, 1, 3, 5};
        int n = parent.length;
        Node node = tree.createTree(parent, n);
        System.out.println("Inorder traversal of constructed tree ");
        tree.inorder(node);
        tree.newLine();
    }
}
 
// This code has been contributed by Mayank Jaiswal(mayank_24)

// Java program to construct a Binary Tree from parent array

// A binary tree node
class Node {
    int key;
    Node left, right;
    public Node() {}
    public Node(int key)
    {
        this.key = key;
        left = right = null;
    }
}

class BinaryTree {
    Node root;

    // Function to construct binary tree from parent array.
    Node createTree(int parent[], int n)
    {
        // Create an array to store the reference
        // of all newly created nodes corresponding
        // to node value
        Node[] ref = new Node[n];

        // This root represent the root of the
        // newly constructed tree
        Node root = new Node();

        // Create n new tree nodes, each having
        // a value from 0 to n-1, and store them
        // in ref
        for (int i = 0; i < n; i++) {
            Node temp = new Node(i);
            ref[i] = temp;
        }

        // Traverse the parent array and build the tree
        for (int i = 0; i < n; i++) {

            // If the parent is -1, set the root
            // to the current node having
            // the value i which is stored in ref[i]
            if (parent[i] == -1) {
                root = ref[i];
            }
            else {
                // Check if the parent's left child
                // is NULL then map the left child
                // to its parent.
                if (ref[parent[i]].left == null)
                    ref[parent[i]].left = ref[i];
                else
                    ref[parent[i]].right = ref[i];
            }
        }

        // Return the root of the newly constructed tree
        return root;
    }

    // function for inorder traversal
    void inorder(Node node)
    {
        if (node != null) {
            inorder(node.left);
            System.out.print(node.key + " ");
            inorder(node.right);
        }
    }

    // Driver code
    public static void main(String[] args)
    {

        BinaryTree tree = new BinaryTree();
        int parent[] = new int[] { -1, 0, 0, 1, 1, 3, 5 };
        int n = parent.length;
        Node node = tree.createTree(parent, n);
        System.out.println(
            "Inorder traversal of constructed tree ");
        tree.inorder(node);
    }
}

// This code has been contributed by Abhijeet Kumar(abhijeet19403)

// Java code of the above approach
import java.util.*;

class Node {
    int val;
    Node left;
    Node right;

    Node(int val)
    {
        this.val = val;
        left = null;
        right = null;
    }
}

public class GFG {
    // Function to perform an inorder traversal of a binary
    // tree
    static void inorder(Node node)
    {
        if (node != null) {
            inorder(node.left);
            System.out.print(node.val + " ");
            inorder(node.right);
        }
    }

    // Function to create a binary tree from an array of
    // parent nodes
    static Node createTree(List<Integer> parent)
    {
        int n = parent.size();
        Map<Integer, Node> nodes
            = new HashMap<>(); // Map to store created nodes
        Node root = null; // Root of the tree

        for (int i = 0; i < n; ++i) {
            if (parent.get(i) == -1) {
                root = new Node(i); // Create root node
                nodes.put(i, root);
            }
            else {
                Node parentNode = nodes.get(parent.get(
                    i)); // Get parent node from map
                if (parentNode == null) {
                    parentNode = new Node(
                        parent.get(i)); // Create parent
                                        // node if not exist
                    nodes.put(parent.get(i), parentNode);
                }
                Node currentNode
                    = new Node(i); // Create current node
                if (parentNode.left == null) {
                    parentNode.left
                        = currentNode; // Attach to left if
                                       // left is empty
                }
                else {
                    parentNode.right
                        = currentNode; // Otherwise, attach
                                       // to right
                }
                nodes.put(
                    i,
                    currentNode); // Add current node to map
            }
        }
        return root; // Return root of the constructed tree
    }

    public static void main(String[] args)
    {
        List<Integer> parent = Arrays.asList(
            -1, 0, 0, 1, 1, 3, 5); // Parent array
        Node root = createTree(
            parent); // Create tree using parent array

        System.out.println(
            "Inorder traversal of constructed tree:");
        inorder(root); // Perform inorder traversal and
                       // print nodes
    }
}

// This code is contributed by Susobhan Akhuli