Smallest value in each level of Binary Tree

<script>

    // JavaScript program to print smallest element
    // in each level of binary tree.
    
    let INT_MAX = 10e6;
 
    // A Binary Tree Node
    class Node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }

    // return height of tree
    function heightoftree(root)
    {
        if (root == null)
            return 0;

        let left = heightoftree(root.left);
        let right = heightoftree(root.right);

        return ((left > right ? left : right) + 1);
    }

    // Inorder Traversal
    // Search minimum element in each level and
    // store it into vector array.
    function printPerLevelMinimum(root, res, level)
    {
        if (root != null)
        {
            printPerLevelMinimum(root.left, res, level + 1);

            if (root.data < res[level])
                res[level] = root.data;

            printPerLevelMinimum(root.right, res, level + 1);
        }
    }

    function perLevelMinimumUtility(root)
    {

        // height of tree for the size of
        // vector array
        let n = heightoftree(root), i;

        // vector for store all minimum of
        // every level
        let res = new Array(n);
        res.fill(INT_MAX);

        // save every level minimum using
        // inorder traversal
        printPerLevelMinimum(root, res, 0);

        // print every level minimum
        document.write("Every level minimum is" + "</br>");
        for (i = 0; i < n; i++)
        {
            document.write("level " + i +
                             " min is = " +
                            res[i] + "</br>");
        }
    }

    // Utility function to create a new tree node
    function newNode(data)
    {
        let temp = new Node(data);
        temp.data = data;
        temp.left = temp.right = null;

        return temp;
    }
    
    // Let us create binary tree shown
    // in above diagram
    let root = newNode(7);
    root.left = newNode(6);
    root.right = newNode(5);
    root.left.left = newNode(4);
    root.left.right = newNode(3);
    root.right.left = newNode(2);
    root.right.right = newNode(1);
 
    /*     7
        / \
        6     5
    / \     / \
    4 3 2 1         */
    perLevelMinimumUtility(root);

</script>

<script>
    // Javascript program to print minimum element
    // in each level of binary tree.
    
    class Node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }

    // return height of tree
    function heightoftree(root)
    {

        if (root == null)
            return 0;

        let left = heightoftree(root.left);
        let right = heightoftree(root.right);

        return ((left > right ? left : right) + 1);
    }

    // Iterative method to find every level
    // minimum element of Binary Tree
    function printPerLevelMinimum(root)
    {

        // Base Case
        if (root == null)
            return ;

        // Create an empty queue for
        // level order traversal
        let q = [];

        // push the root for Change the level
        q.push(root);

        // for go level by level
        q.push(null);

        let min = Number.MAX_VALUE;
        // for check the level
        let level = 0;

        while (q.length > 0)
        {

            // Get top of queue
            let node = q[0];
            q.shift();

            // if node == null (Means this is
            // boundary between two levels)
            if (node == null)
            {

                document.write("level " + level +
                " min is = " + min+ "</br>");

                // here queue is empty represent
                // no element in the actual
                // queue
                if (q.length == 0)
                    break;

                q.push(null);

                // increment level
                level++;

                // Reset min for next level
                // minimum value
                min = Number.MAX_VALUE;

                continue;
            }

            // get Minimum in every level
            if (min > node.data)
                min = node.data;

            /* Enqueue left child */
            if (node.left != null)
            {
                q.push(node.left);
            }

            /*Enqueue right child */
            if (node.right != null)
            {
                q.push(node.right);
            }
        }
    }

    // Utility function to create a
    // new tree node
    function newNode(data)
    {

        let temp = new Node(data);
        return temp;
    }
    
    // Let us create binary tree shown
    // in above diagram
    let root = newNode(7);
    root.left = newNode(6);
    root.right = newNode(5);
    root.left.left = newNode(4);
    root.left.right = newNode(3);
    root.right.left = newNode(2);
    root.right.right = newNode(1);
 
    /*     7
        / \
    6 5
    / \ / \
    4 3 2 1         */
 
    document.write("Every level minimum is"
    + "</br>");
         
    printPerLevelMinimum(root);

// This code is contributed by decode2207.
</script>