Skip to content
Related Articles

Related Articles

Improve Article

Find the Deepest Node in a Binary Tree Using Queue STL – SET 2

  • Last Updated : 24 Jun, 2021

Given a binary tree. The task is to find the value of the deepĀ­est node in the given binary tree.

Examples: 

Input: Root of below tree
            1
          /   \
         2      3
        / \    / \ 
       4   5  6   7
                   \
                    8
Output: 8

Input: Root of below tree
            1
          /   \
         2      3
               / 
              6  
Output: 6

Approach: We have already discussed the two different ways to find the deepest node in a binary tree in this post. Here, we will find the deepest node in the tree using a queue data structure. We will first push the root into the queue and then we will push it’s child nodes after removing parent node from the queue. We will continue this process until the queue empty. The last node in the queue is the deepest node of the binary tree.

Below is the implementation of the above approach : 

C++




// C++ program to find the value of the
// deepest node in a given binary tree.
#include <bits/stdc++.h>
using namespace std;
 
// A tree node
struct Node
{
    int data;
    struct Node *left , *right;
};
 
// Utility function to create a new node
Node *newNode(int data)
{
    Node *temp = new Node;
    temp->data = data;
    temp->left = temp->right = NULL;
    return temp;
}
 
// Function to find the deepest node in a tree
int findDeepest(struct Node* root) {
 
    struct Node* temp = NULL;
     
    queue <Node *> q;
 
    if(root == NULL)
        return 0;
     
    // Push the root node
    q.push(root);
 
    while(!q.empty()) {
 
        temp = q.front();
        q.pop();
         
        // Push left child
        if(temp->left)
            q.push(temp->left);
         
        // Push right child
        if(temp->right)
            q.push(temp->right);
    }
     
    // Return the deepest node's value
    return temp->data;
}
 
// Driver code
int main()
{
    Node* root = newNode(1);
    root->left = newNode(2);
    root->right = newNode(3);
    root->left->left = newNode(4);
    root->right->left = newNode(5);
    root->right->right = newNode(6);
    root->right->left->right = newNode(7);
    root->right->right->right = newNode(8);
    root->right->left->right->left = newNode(9);
     
    // Function call
    cout << findDeepest(root);
     
    return 0;
}

Java




// Java program to find the value of the
// deepest node in a given binary tree.
import java.util.*;
 
class GFG
{
 
// A tree node
static class Node
{
    int data;
    Node left , right;
};
 
// Utility function to create a new node
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the deepest node in a tree
static int findDeepest(Node root)
{
    Node temp = null;
     
    Queue <Node> q = new LinkedList<Node>();
 
    if(root == null)
        return 0;
     
    // Push the root node
    q.add(root);
 
    while(!q.isEmpty())
    {
        temp = q.peek();
        q.remove();
         
        // Push left child
        if(temp.left!=null)
            q.add(temp.left);
         
        // Push right child
        if(temp.right!=null)
            q.add(temp.right);
    }
     
    // Return the deepest node's value
    return temp.data;
}
 
// Driver code
public static void main(String[] args)
{
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.right.left = newNode(5);
    root.right.right = newNode(6);
    root.right.left.right = newNode(7);
    root.right.right.right = newNode(8);
    root.right.left.right.left = newNode(9);
     
    // Function call
    System.out.println(findDeepest(root));
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Python3 program to find the value of the
# deepest node in a given binary tree.
from collections import deque
 
# A tree node
class Node:
     
    def __init__(self, data):
         
        self.data = data
        self.left = None
        self.right = None
 
# Function to find the deepest node in a tree
def findDeepest(root: Node) -> int:
 
    temp = None
    q = deque()
 
    if (root == None):
        return 0
 
    # Push the root node
    q.append(root)
 
    while q:
        temp = q[0]
        q.popleft()
 
        # Push left child
        if (temp.left):
            q.append(temp.left)
 
        # Append right child
        if (temp.right):
            q.append(temp.right)
 
    # Return the deepest node's value
    return temp.data
 
# Driver code
if __name__ == "__main__":
 
    root = Node(1)
    root.left = Node(2)
    root.right = Node(3)
    root.left.left = Node(4)
    root.right.left = Node(5)
    root.right.right = Node(6)
    root.right.left.right = Node(7)
    root.right.right.right = Node(8)
    root.right.left.right.left = Node(9)
 
    # Function call
    print(findDeepest(root))
 
# This code is contributed by sanjeev2552

C#




// C# program to find the value of the
// deepest node in a given binary tree.
using System;
using System.Collections.Generic;
 
class GFG
{
 
// A tree node
public class Node
{
    public int data;
    public Node left , right;
};
 
// Utility function to create a new node
static Node newNode(int data)
{
    Node temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the deepest node in a tree
static int findDeepest(Node root)
{
    Node temp = null;
     
    Queue <Node> q = new Queue <Node>();
 
    if(root == null)
        return 0;
     
    // Push the root node
    q.Enqueue(root);
 
    while(q.Count != 0)
    {
        temp = q.Peek();
        q.Dequeue();
         
        // Push left child
        if(temp.left != null)
            q.Enqueue(temp.left);
         
        // Push right child
        if(temp.right != null)
            q.Enqueue(temp.right);
    }
     
    // Return the deepest node's value
    return temp.data;
}
 
// Driver code
public static void Main(String[] args)
{
    Node root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.right.left = newNode(5);
    root.right.right = newNode(6);
    root.right.left.right = newNode(7);
    root.right.right.right = newNode(8);
    root.right.left.right.left = newNode(9);
     
    // Function call
    Console.WriteLine(findDeepest(root));
}
}
     
// This code is contributed by PrinciRaj1992

Javascript




<script>
 
// Javascript program to find the value of the
// deepest node in a given binary tree.
 
// A tree node
class Node
{
    constructor()
    {
        this.data = 0;
        this.left = null;
        this.right = null;
    }
};
 
// Utility function to create a new node
function newNode(data)
{
    var temp = new Node();
    temp.data = data;
    temp.left = temp.right = null;
    return temp;
}
 
// Function to find the deepest node in a tree
function findDeepest(root)
{
    var temp = null;
    var q = [];
 
    if (root == null)
        return 0;
     
    // Push the root node
    q.push(root);
 
    while (q.length != 0)
    {
        temp = q[0];
        q.shift();
         
        // Push left child
        if (temp.left != null)
            q.push(temp.left);
         
        // Push right child
        if (temp.right != null)
            q.push(temp.right);
    }
     
    // Return the deepest node's value
    return temp.data;
}
 
// Driver code
var root = newNode(1);
root.left = newNode(2);
root.right = newNode(3);
root.left.left = newNode(4);
root.right.left = newNode(5);
root.right.right = newNode(6);
root.right.left.right = newNode(7);
root.right.right.right = newNode(8);
root.right.left.right.left = newNode(9);
 
// Function call
document.write(findDeepest(root));
 
// This code is contributed by noob2000
 
</script>

Output: 

 9

Time Complexity: O(N)
 

Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.



My Personal Notes arrow_drop_up
Recommended Articles
Page :