JavaScript Program for Rightmost and Leftmost Node of a Binary Tree

A binary tree is a fundamental data structure consisting of nodes, each with at most two children: a left child and a right child. The topmost node is called the root. Binary trees support operations such as insertion, deletion, and various traversal methods like in-order, pre-order, and post-order traversal. They find applications in databases, compilers, and algorithms like Huffman coding, though maintaining balance and efficient memory management are crucial considerations.

Input: Given a binary tree. Your task is to print the value of the leftmost and rightmost node at each level of the given binary tree.

Output:  1 , 2 ,3 , 4 ,6
Explanation:  The given values are the values of nodes which are on leftmost and rightmost side of the given binary tree.

Program to find leftmost and rightmost side of Binary Tree

If we observe the given problem carefully we have to print the value of first and last node of each level of the tree. As we are dealing with levels we can use level order traversal for this problem. We will do the level order traversal on the given tree and then print the value of first and last node at each level. We will follow the steps given below to solve this problem.

• Create a Queue and add the root node to it.
• Now create a while loop which will run unless the queue will become empty.
• Store the current size of the queue in a variable.
• Now in the while loop start a for loop which will run from 0 to the current size of the queue.
• Now remove nodes from the queue one by one.
• If i in for loop is 0 or equal to the 1 lesser than size of the queue then print the value of node.
• For each node check whether left and right childe exist and if they exit then insert them into the queue.

Example: The code demonstrates breadth-first traversal of a binary tree to print the leftmost and rightmost nodes at each level.

class Node {
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
}

function printLeftmostAndRightmost(root) {
    if (root === null) {
        return;
    }

    // Initialize a queue and add the root node in queue
    let queue = [];
    queue.push(root);

    // Loop until queue is empty
    while (queue.length > 0) {
        let levelSize = queue.length;

        // Traverse nodes at the current level
        for (let i = 0; i < levelSize; i++) {
            let node = queue.shift();

            // Print the leftmost node (i == 0) and 
            rightmost node (i == levelSize - 1)
            if (i == 0 || i == levelSize - 1) {
                console.log(node.data);
            }

            // Add  left child to the queue if it exists
            if (node.left !== null) {
                queue.push(node.left);
            }

            // Add right child to the queue if it exists
            if (node.right !== null) {
                queue.push(node.right);
            }
        }
    }
}

// Example usage:
let root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);
root.right.left = new Node(6);
root.right.right = new Node(7);

printLeftmostAndRightmost(root); 

1
2
3
4
7

Time complexity: O(N), where n is a no of nodes.

Space complexity: O(N)