Construct BST from its given level order traversal

// C# implementation to construct a BST
// from its level order traversal
using System;

class GFG {

    // node of a BST
    public class Node {
        public int data;
        public Node left, right;
    };

    // function to get a new node
    static Node getNode(int data)
    {
        // Allocate memory
        Node newNode = new Node();

        // put in the data
        newNode.data = data;
        newNode.left = newNode.right = null;
        return newNode;
    }

    // function to construct a BST from
    // its level order traversal
    static Node LevelOrder(Node root, int data)
    {
        if (root == null) {
            root = getNode(data);
            return root;
        }

        if (data <= root.data)
            root.left = LevelOrder(root.left, data);
        else
            root.right = LevelOrder(root.right, data);
        return root;
    }

    static Node constructBst(int[] arr, int n)
    {
        if (n == 0)
            return null;
        Node root = null;

        for (int i = 0; i < n; i++)
            root = LevelOrder(root, arr[i]);

        return root;
    }

    // function to print the inorder traversal
    static void inorderTraversal(Node root)
    {
        if (root == null)
            return;

        inorderTraversal(root.left);
        Console.Write(root.data + " ");
        inorderTraversal(root.right);
    }

    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 7, 4, 12, 3, 6, 8, 1, 5, 10 };
        int n = arr.Length;

        Node root = constructBst(arr, n);

        Console.Write("Inorder Traversal: ");
        inorderTraversal(root);
    }
}

// This code is contributed by Rajput-Ji

using System;
using System.Collections.Generic;

// Node of a BST
class Node {
    public int data;
    public Node left;
    public Node right;

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

class BST {
    public Node constructBst(int[] arr, int n)
    {
        var queue
            = new Queue<Tuple<Node, Tuple<int, int> > >();

        if (n == 0)
            return null;

        // Create root node and store a copy of it in head
        var root = new Node(arr[0]);
        var head = root;

        // Push the root node and the initial range
        queue.Enqueue(
            Tuple.Create(root, Tuple.Create(int.MinValue,
                                            int.MaxValue)));
        int i = 1;

        // Loop over the contents of arr to process all the
        // elements using while loop we may have to process
        // atmost 2 child's
        while (i < n) {
            // Get the node and the range at the front of
            // the queue and popout the leftmost element
            var temp = queue.Dequeue();
            var tempRange = temp.Item2;

            // Check if arr[i] can be left child and within
            // range of it's parent data
            if (arr[i] < temp.Item1.data
                && tempRange.Item1 < arr[i]
                && arr[i] < tempRange.Item2) {
                // Set the left child and new range for the
                // child
                temp.Item1.left = new Node(arr[i]);
                queue.Enqueue(Tuple.Create(
                    temp.Item1.left,
                    Tuple.Create(tempRange.Item1,
                                 temp.Item1.data)));
                i++;
            }

            // Check if arr[i] can be right child and within
            // range of it's parent data
            if (arr[i] > temp.Item1.data
                && tempRange.Item1 < arr[i]
                && arr[i] < tempRange.Item2) {
                // Set the right child and new range for the
                // child
                temp.Item1.right = new Node(arr[i]);
                queue.Enqueue(Tuple.Create(
                    temp.Item1.right,
                    Tuple.Create(temp.Item1.data,
                                 tempRange.Item2)));
                i++;
            }
        }
        return head;
    }

    public void inorderTraversal(Node root)
    {
        if (root == null)
            return;

        inorderTraversal(root.left);
        Console.Write(root.data + " ");
        inorderTraversal(root.right);
    }

    // Driver program
    public static void Main(string[] args)
    {

        var arr = new int[] { 7, 4, 12, 3, 6, 8, 1, 5, 10 };
        int n = arr.Length;

        var bst = new BST();
        var root = bst.constructBst(arr, n);

        Console.WriteLine("Inorder Traversal:");
        bst.inorderTraversal(root);
    }
}