Print left and right leaf nodes separately in Binary Tree

Given a binary tree, the task is to print left and right leaf nodes separately.

Examples:

Input:
       0
     /   \
   1      2
 /  \
3    4 
Output:
Left Leaf Nodes: 3
Right Leaf Nodes: 4 2

Input:
   0
     \
      1
       \
        2
         \
          3
Output:
Left Leaf Nodes: None
Right Leaf Nodes: 3

Approach:

• Check if given node is null. If null, then return from the function.
• For each traversal at right and left, send information about the child (left or right child) using the parameter type. Set type = 0 while descending to the left branch and set type = 1 for the right branch.
• Check if it is a leaf node. If the node is a leaf node, then store the leaf node in one of the two vectors of left and right child.
• If node is not a leaf node continue traversal.
• In the case of a single node tree, it will be both a root and a leaf node. This case has to be handled separately.

Below is the implementation of the above approach: 

C++

// C++ program for the
// above approach

#include <bits/stdc++.h>

using namespace std;

// Structure for
// Binary Tree Node
struct Node {
    int data;
    Node* left;
    Node* right;
    Node(int x)
        : data(x)
        , left(NULL)
        , right(NULL)
    {
    }
};

// Function for
// dfs traversal
void dfs(Node* root, int type, vector<int>& left_leaf,
         vector<int>& right_leaf)
{
    // If node is
    // null, return
    if (!root) {
        return;
    }

    // If tree consists
    // of a single node
    if (!root->left && !root->right) {
        if (type == -1) {
            cout << "Tree consists of a single node\n";
        }
        else if (type == 0) {
            left_leaf.push_back(root->data);
        }
        else {
            right_leaf.push_back(root->data);
        }

        return;
    }

    // If left child exists,
    // traverse and set type to 0
    if (root->left) {
        dfs(root->left, 0, left_leaf, right_leaf);
    }
    // If right child exists,
    // traverse and set type to 1
    if (root->right) {
        dfs(root->right, 1, left_leaf, right_leaf);
    }
}

// Function to print
// the solution
void print(vector<int>& left_leaf, vector<int>& right_leaf)
{

    if (left_leaf.size() == 0 && right_leaf.size() == 0)
        return;

    // Printing left leaf nodes
    cout << "Left leaf nodes\n";
    for (int x : left_leaf) {
        cout << x << " ";
    }
    cout << '\n';

    // Printing right leaf nodes
    cout << "Right leaf nodes\n";
    for (int x : right_leaf) {
        cout << x << " ";
    }
    cout << '\n';
}

// Driver code
int main()
{

    Node* root = new Node(0);
    root->left = new Node(1);
    root->right = new Node(2);
    root->left->left = new Node(3);
    root->left->right = new Node(4);

    vector<int> left_leaf, right_leaf;
    dfs(root, -1, left_leaf, right_leaf);

    print(left_leaf, right_leaf);

    return 0;
}

Java

// Java program for the
// above approach
import java.util.*;

class GFG
{

    // Structure for
    // Binary Tree Node
    static class Node
    {
        int data;
        Node left;
        Node right;

        public Node(int data)
        {
            this.data = data;
            this.left = null;
            this.right = null;
        }

    };

    // Function for
    // dfs traversal
    static void dfs(Node root, int type, Vector<Integer> left_leaf,
            Vector<Integer> right_leaf)
    {
        // If node is
        // null, return
        if (root == null)
        {
            return;
        }

        // If tree consists
        // of a single node
        if (root.left == null && root.right == null)
        {
            if (type == -1)
            {
                System.out.print("Tree consists of a single node\n");
            }
            else if (type == 0)
            {
                left_leaf.add(root.data);
            }
            else
            {
                right_leaf.add(root.data);
            }

            return;
        }

        // If left child exists,
        // traverse and set type to 0
        if (root.left != null)
        {
            dfs(root.left, 0, left_leaf, right_leaf);
        }

        // If right child exists,
        // traverse and set type to 1
        if (root.right != null)
        {
            dfs(root.right, 1, left_leaf, right_leaf);
        }
    }

    // Function to print
    // the solution
    static void print(Vector<Integer> left_leaf,
                    Vector<Integer> right_leaf)
    {

        if (left_leaf.size() == 0 && right_leaf.size() == 0)
            return;

        // Printing left leaf nodes
        System.out.print("Left leaf nodes\n");
        for (int x : left_leaf)
        {
            System.out.print(x + " ");
        }
        System.out.println();

        // Printing right leaf nodes
        System.out.print("Right leaf nodes\n");
        for (int x : right_leaf)
        {
            System.out.print(x + " ");
        }
        System.out.println();
    }

    // Driver code
    public static void main(String[] args)
    {

        Node root = new Node(0);
        root.left = new Node(1);
        root.right = new Node(2);
        root.left.left = new Node(3);
        root.left.right = new Node(4);

        Vector<Integer> left_leaf = new Vector<Integer>(),
                right_leaf = new Vector<Integer>();
        dfs(root, -1, left_leaf, right_leaf);

        print(left_leaf, right_leaf);

    }
}

// This code is contributed by PrinciRaj1992

Python3

# Python3 program for the
# above approach

# Structure for
# Binary Tree Node
class Node:

    def __init__(self, data):

        self.data = data
        self.left = None
        self.right = None

# Function for
# dfs traversal
def dfs(root, type_t, left_leaf,
        right_leaf):

    # If node is
    # null, return
    if (not root):
        return

    # If tree consists
    # of a single node
    if (not root.left and not root.right):
        if (type_t == -1):
            print("Tree consists of a single node")

        elif (type_t == 0):
            left_leaf.append(root.data)

        else:
            right_leaf.append(root.data)

        return

    # If left child exists,
    # traverse and set type_t to 0
    if (root.left):
        dfs(root.left, 0, left_leaf,
            right_leaf)

    # If right child exists,
    # traverse and set type_t to 1
    if (root.right):
        dfs(root.right, 1, left_leaf,
            right_leaf)

# Function to print
# the solution
def prints(left_leaf, right_leaf):

    if (len(left_leaf) == 0 and
        len(right_leaf) == 0):
        return

    # Printing left leaf nodes
    print("Left leaf nodes")

    for x in left_leaf:
        print(x, end = ' ')

    print()

    # Printing right leaf nodes
    print("Right leaf nodes")

    for x in right_leaf:
        print(x, end = ' ')

    print()

# Driver code
if __name__=='__main__':

    root = Node(0)
    root.left = Node(1)
    root.right = Node(2)
    root.left.left = Node(3)
    root.left.right = Node(4)

    left_leaf = []
    right_leaf = []
    dfs(root, -1, left_leaf, right_leaf)

    prints(left_leaf, right_leaf)

# This code is contributed by pratham76

C#

// C# program for the
// above approach
using System;
using System.Collections.Generic;

class GFG
{

    // Structure for
    // Binary Tree Node
    public class Node
    {
        public int data;
        public Node left;
        public Node right;

        public Node(int data)
        {
            this.data = data;
            this.left = null;
            this.right = null;
        }

    };

    // Function for
    // dfs traversal
    static void dfs(Node root, int type, List<int> left_leaf,
            List<int> right_leaf)
    {
        // If node is
        // null, return
        if (root == null)
        {
            return;
        }

        // If tree consists
        // of a single node
        if (root.left == null && root.right == null)
        {
            if (type == -1)
            {
                Console.Write("Tree consists of a single node\n");
            }
            else if (type == 0)
            {
                left_leaf.Add(root.data);
            }
            else
            {
                right_leaf.Add(root.data);
            }

            return;
        }

        // If left child exists,
        // traverse and set type to 0
        if (root.left != null)
        {
            dfs(root.left, 0, left_leaf, right_leaf);
        }

        // If right child exists,
        // traverse and set type to 1
        if (root.right != null)
        {
            dfs(root.right, 1, left_leaf, right_leaf);
        }
    }

    // Function to print
    // the solution
    static void print(List<int> left_leaf,
                    List<int> right_leaf)
    {

        if (left_leaf.Count == 0 && right_leaf.Count == 0)
            return;

        // Printing left leaf nodes
        Console.Write("Left leaf nodes\n");
        foreach (int x in left_leaf)
        {
            Console.Write(x + " ");
        }
        Console.WriteLine();

        // Printing right leaf nodes
        Console.Write("Right leaf nodes\n");
        foreach (int x in right_leaf)
        {
            Console.Write(x + " ");
        }
        Console.WriteLine();
    }

    // Driver code
    public static void Main(String[] args)
    {

        Node root = new Node(0);
        root.left = new Node(1);
        root.right = new Node(2);
        root.left.left = new Node(3);
        root.left.right = new Node(4);

        List<int> left_leaf = new List<int>(),
                right_leaf = new List<int>();
        dfs(root, -1, left_leaf, right_leaf);

        print(left_leaf, right_leaf);

    }
}

// This code is contributed by PrinciRaj1992

Javascript

<script>

// JavaScript program for the
// above approach
// Structure for
// Binary Tree Node
class Node
{
    constructor(data)
    {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};
// Function for
// dfs traversal
function dfs(root, type, left_leaf, right_leaf)
{
    // If node is
    // null, return
    if (root == null)
    {
        return;
    }
    // If tree consists
    // of a single node
    if (root.left == null && root.right == null)
    {
        if (type == -1)
        {
            document.write("Tree consists of a single node<br>");
        }
        else if (type == 0)
        {
            left_leaf.push(root.data);
        }
        else
        {
            right_leaf.push(root.data);
        }
        return;
    }
    // If left child exists,
    // traverse and set type to 0
    if (root.left != null)
    {
        dfs(root.left, 0, left_leaf, right_leaf);
    }

    // If right child exists,
    // traverse and set type to 1
    if (root.right != null)
    {
        dfs(root.right, 1, left_leaf, right_leaf);
    }
}
// Function to print
// the solution
function print(left_leaf, right_leaf)
{
    if (left_leaf.Count == 0 && right_leaf.Count == 0)
        return;
    // Printing left leaf nodes
    document.write("Left leaf nodes<br>");

    for(var x of left_leaf)
    {
        document.write(x + " ");
    }
    document.write("<br>");

    // Printing right leaf nodes
    document.write("Right leaf nodes<br>");
    for(var x of right_leaf)
    {
        document.write(x + " ");
    }
    document.write("<br>");
}

// Driver code
var root = new Node(0);
root.left = new Node(1);
root.right = new Node(2);
root.left.left = new Node(3);
root.left.right = new Node(4);
var left_leaf = [];
var right_leaf = [];
dfs(root, -1, left_leaf, right_leaf);
print(left_leaf, right_leaf);

</script>

Output:

Left leaf nodes
3 
Right leaf nodes
4 2

Time complexity: O(h) where h is height of given Binary Tree