Printing the **left view** of a binary tree involves printing the left-most node, at each level, in the binary tree.


Printing the left view of the Binary tree, given above, would involve printing the nodes: $1, 2, 11,$ and $15$.

# Algorithm
This problem is solved by recursively traversing each level in the tree(visiting the left node before the right node). Whenever we move to the next level, print the leftmost node in that level (Note: we traverse the left subtree before the right subtree). The variable `maxlevel` is used to track the maximum level in the tree that is traversed so far. Each time a node with a level greater than `maxlevel` is encountered, its value is printed, ​and the value of `maxlevel` is updated to that value.

# Implementation

#include <bits/stdc++.h> 
using namespace std; 
  
class node { 
public: 
  int data; 
  node *left, *right; 
}; 
  
// A function to create a new node in the tree
node* newNode(int item) 
{ 
  node* temp = new node(); 
  temp->data = item; 
  temp->left = temp->right = NULL; 
  return temp; 
} 
  
// Recursive function to print left view of a binary tree.
// It takes a root, the current level, and 
// the max level so far of the binary tree
void leftViewUtil(node* root, int level, int* max_level) 
{ 
  if (root == NULL) 
    return; 

  // If we are moving to a new level, print the first node(left-most)
  if (*max_level < level) { 
    cout << root->data << "\t"; 
    *max_level = level; 
  } 

  leftViewUtil(root->left, level + 1, max_level); 
  leftViewUtil(root->right, level + 1, max_level); 
} 
  
void leftView(node* root) 
{ 
  int max_level = 0; 
  leftViewUtil(root, 1, &max_level); 
} 
  
// Driver code 
int main() 
{
  // creating the tree.
  node* root = newNode(1); 
  root->left = newNode(2); 
  root->right = newNode(4); 
  root->left->left = newNode(11); 
  root->left->left->right = newNode(15); 
  root->right->left = newNode(9); 
  root->right->right = newNode(3); 

  leftView(root); 

  return 0; 
} 

class Node: 
  def __init__(self, data): 
    self.data = data 
    self.left = None
    self.right = None
  
  
# Recursive function to print left view of a binary tree.
# It takes a root, the current level, and 
# the max level so far of the binary tree
def leftViewUtil(root, level, max_level): 
  if root is None: 
    return

  if (max_level[0] < level): 
    print ("% d " %(root.data)), 
    max_level[0] = level 

  leftViewUtil(root.left, level + 1, max_level) 
  leftViewUtil(root.right, level + 1, max_level) 
  
def leftView(root): 
  max_level = [0] 
  leftViewUtil(root, 1, max_level) 
  
  
# Driver program to test above function 
root = Node(1) 
root.left = Node(2); 
root.right = Node(4); 
root.left.left = Node(11); 
root.left.left.right = Node(15); 
root.right.left = Node(9); 
root.right.right = Node(3);
  
leftView(root) 

Python

class Node { 
  int data; 
  Node left, right; 

  public Node(int item) 
  { 
    data = item; 
    left = right = null; 
  } 
} 
  
class BinaryTree { 
  Node root; 
  static int max_level = 0; 

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

    if (max_level < level) { 
      System.out.print(" " + node.data); 
      max_level = level; 
    } 

    leftViewUtil(node.left, level + 1); 
    leftViewUtil(node.right, level + 1); 
  } 

  void leftView() 
  { 
      leftViewUtil(root, 1); 
  } 

  public static void main(String args[]) 
  { 
    /* creating a binary tree and entering the nodes */
    BinaryTree tree = new BinaryTree(); 
    tree.root = new Node(1); 
    tree.root.left = new Node(2); 
    tree.root.right = new Node(4); 
    tree.root.left.left = new Node(11); 
    tree.root.left.left.right = new Node(15); 
    tree.root.right.left = new Node(9); 
    tree.root.right.right = new Node(3);

    tree.leftView(); 
  } 
} 

Java

How to print the left view of a binary tree

Printing the left view of a binary tree involves printing the left-most node, at each level, in the binary tree. 