Print leftmost and rightmost nodes of a Binary Tree

Given a Binary Tree, Print the corner nodes at each level. The node at the leftmost and the node at the rightmost.

For example, output for following is 15, 10, 20, 8, 25.



A Simple Solution is to do two traversals using the approaches discussed for printing left view and right view.

Can we print all corner nodes using one traversal?
The idea is to use Level Order Traversal. To find first node, we use a variable isFirst. To separate levels, we enqueue NULL after every level. So in level order traversal, if we see a NULL, we know next node would be first node of its level and therefore we set isFirst.

A special case to consider is, a tree like below.

   1
    \
     2
      \
       3

The output for above tree should be 1, 2, 3. We need make sure that the levels having only one node are handled and the node is printed only once. For this purpose, we maintain a separate variable isOne.

C++

// C/C++ program to print corner node at each level
// of binary tree
#include <bits/stdc++.h>
using namespace std;
  
/* A binary tree node has key, pointer to left
   child and a pointer to right child */
struct Node
{
    int key;
    struct Node* left, *right;
};
  
/* To create a newNode of tree and return pointer */
struct Node* newNode(int key)
{
    Node* temp = new Node;
    temp->key = key;
    temp->left = temp->right = NULL;
    return (temp);
}
  
/* Function to print corner node at each level */
void printCorner(Node *root)
{
    //    star node is for keeping track of levels
    queue<Node *> q;
  
    // pushing root node and star node
    q.push(root);
    q.push(NULL);
  
    // if isFirst = true then left most node of that level
    // will be printed
    bool isFirst = false;
  
    // if isOne = true then that level has only one node
    bool isOne = false;
  
    // last will store right most node of that level
    int last;
  
    // Do level order traversal of Binary Tree
    while (!q.empty())
    {
        // dequeue the front node from the queue
        Node *temp = q.front();
        q.pop();
  
        // if isFirst is true, then temp is leftmost node
        if (isFirst)
        {
            cout << temp->key << "  ";
  
            if (temp->left)
                q.push(temp->left);
            if (temp->right)
                q.push(temp->right);
  
            // make isFirst as false and one = 1
            isFirst = false;
            isOne = true;
        }
  
        // Else if temp is a separator between two levels
        else if (temp == NULL)
        {
            // Insert new separator if there are items in queue
            if (q.size() >= 1)
                q.push(NULL);
  
            // making isFirst as true because next node will be
            // leftmost node of that level
            isFirst = true;
  
            // printing last node, only if that level
            // doesn't contain single node otherwise
            // that single node will be printed twice              
            if (!isOne)
                cout << last << "  ";
        }
        else
        {
            // Store current key as last
            last = temp->key;
  
            // Here we are making isOne = false to signify
            // that level has more than one node
            isOne = false;
            if (temp->left)
                q.push(temp->left);
            if (temp->right)
                q.push(temp->right);
        }
    }
}
  
// Driver program to test above function
int main ()
{
    Node *root =  newNode(15);
    root->left = newNode(10);
    root->right = newNode(20);
    root->left->left = newNode(8);
    root->left->right = newNode(12);
    root->right->left = newNode(16);
    root->right->right = newNode(25);
    printCorner(root);
    return 0; 
}

Java

// Java program to print corner node at each level in a binary tree
  
import java.util.*;
  
/* A binary tree node has key, pointer to left
   child and a pointer to right child */
class Node 
{
    int key;
    Node left, right;
  
    public Node(int key) 
    {
        this.key = key;
        left = right = null;
    }
}
  
class BinaryTree 
{
    Node root;
  
    /* Function to print corner node at each level */
    void printCorner(Node root)
    {
        //  star node is for keeping track of levels
        Queue<Node> q = new LinkedList<Node>();
  
        // pushing root node and star node
        q.add(root);
        q.add(null);
  
        // if isFirst = true then left most node of that level
        // will be printed
        boolean isFirst = false;
  
        // if isOne = true then that level has only one node
        boolean isOne = false;
  
        // last will store right most node of that level
        int last = 0;
  
        // Do level order traversal of Binary Tree
        while (!q.isEmpty()) 
        {
            // dequeue the front node from the queue
            Node temp = q.peek();
            q.poll();
  
            // if isFirst is true, then temp is leftmost node
            if (isFirst) 
            {
                System.out.print(temp.key + "  ");
  
                if (temp.left != null)
                    q.add(temp.left);
                if (temp.right != null)
                    q.add(temp.right);
                  
                // make isFirst as false and one = 1
                isFirst = false;
                isOne = true;
            
              
            // Else if temp is a separator between two levels
            else if (temp == null
            {
                // Insert new separator if there are items in queue
                if (q.size() >= 1
                    q.add(null);
                  
                // making isFirst as true because next node will be
                // leftmost node of that level
                isFirst = true;
  
                // printing last node, only if that level
                // doesn't contain single node otherwise
                // that single node will be printed twice              
                if (!isOne)
                    System.out.print(last + "  ");    
            
            else
            {
                // Store current key as last
                last = temp.key;
  
                // Here we are making isOne = false to signify
                // that level has more than one node
                isOne = false;
                if (temp.left != null)
                    q.add(temp.left);
                if (temp.right != null)
                    q.add(temp.right);               
            }
        }
    }
  
    // Driver program to test above functions
    public static void main(String[] args) 
    {
        BinaryTree tree = new BinaryTree();
        tree.root = new Node(15);
        tree.root.left = new Node(10);
        tree.root.right = new Node(20);
        tree.root.left.left = new Node(8);
        tree.root.left.right = new Node(12);
        tree.root.right.left = new Node(16);
        tree.root.right.right = new Node(25);
  
        tree.printCorner(tree.root);
    }
}
  
// This code has been contributed by Mayank Jaiswal(mayank_24)


Output :

15  10  20  8  25  

Time Complexity : O(n) where n is number of nodes in Binary Tree.

This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up


Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.