Left View of a Binary Tree

A Binary Tree's left view is a collection of the level's leftmost nodes.

Example:

Input:

Output:

4 5 3 6

Method 1: Iterative Implementation

Perform a level order traversal on the tree in the iterative version. To keep nodes at the current level, we can change the level order traversal. Print the current node if it is the first node in the current level.

Method 2: Using Recursion

The approach is to use recursion to find the binary tree's left view. A parameter can be passed to all recursive calls to determine a node's level. When we come across a node with a level greater than the highest level found thus far, we display it. This is due to the fact that it is the first node encountered at this level. We must traverse in such a way that the left subtree is visited before the right subtree in order to display the left view of a binary tree.

Program:

// A Recursive function to print the nodes
// of left view of a binary tree.

void leftViewUtil(Node node, int level)
    {
        // Base Case
        if (node == null)
            return;

        // If this is the left most Node of its level
        if (max_level < level) {
            System.out.print(" " + node.val);
            max_level = level;
        }

        // Recur call for left subtree first,
          // then right subtree
        leftViewUtil(node.left, level + 1);
        leftViewUtil(node.right, level + 1);
    }

Output:

 The following are the nodes present in the left view of the Binary Tree: 
20 22 25 14 7

Hashing can also be used in a recursive implementation.

We can also use hashing to solve this problem. The plan is to preorder the tree's traversal while passing function arguments with level information. If the level is visited for the first time, add the information about the current node and level to the map. After processing each node, navigate the map and print the left view.

Program:

C++:

/* A binary tree node

struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
    
    Node(int x){
        data = x;
        left = right = NULL;
    }
};
 */

//Function to return a list containing elements of left view of the binary tree.
vector<int> leftView(Node *root)
{
    
   vector<int>v;
    if(root==NULL){
       
       return v;
       // for returning empty vector just simply return it
    }
   
   queue<Node*>q;
   q.push(root);
   
   while(q.size()>0){
      int count=q.size();
       
       
       for(int i=0;i<count;i++){
       Node*curr=q.front();
       q.pop();
           
          if(i==0){ v.push_back(curr->data);}
          
          if(curr->left!=NULL){
              q.push(curr->left);
          }
          if(curr->right!=NULL){
              q.push(curr->right);
          }
       }
       
    // code is similar to level order transversal but only at i==0 it will push in vector/print on screen   
       
       
   }
      return v; 
   }

Java:

/* A Binary Tree node
class Node
{
    int data;
    Node left, right;

    Node(int item)
    {
        data = item;
        left = right = null;
    }
}*/


class TreeNodeInfo5
{
    // For Left and Right View Traversal
    Node node;
    int level;

    public TreeNodeInfo5(Node node, int level)
    {
        this.node = node;
        this.level = level;
    }
}

class Tree
{
    //Function to return list containing elements of left view of binary tree.
    ArrayList<Integer> leftView(Node root)
    {
        return leftViewTraversal2(root);
    }
    
    private static ArrayList<Integer> leftViewTraversal2(Node root)
    {
        /*
            TC: O(n)
            SC: O(n)
         */
        ArrayList<Integer> res = new ArrayList<>();
        if(root == null) { return res; }

        HashMap<Integer, Integer> leftView = new HashMap<>();

        leftViewTraversalHelper(root, 1, leftView);

        for(int i=1; i<=leftView.size(); i++)
        {
            res.add(leftView.get(i));
        }

        return res;
    }

    private static void leftViewTraversalHelper(Node root, int level, HashMap<Integer, Integer> leftView)
    {
        if(root == null) { return; }

        leftView.put(level, root.data);
        leftViewTraversalHelper(root.right, level+1, leftView);
        leftViewTraversalHelper(root.left, level+1, leftView);
    }
}

Output:

For the following input: