Deepest left leaf node in a binary tree | iterative approach

Given a Binary Tree, find the deepest leaf node that is left child of its parent. For example, consider the following tree. The deepest left leaf node is the node with value 9.

Examples:

```Input :
1
/   \
2     3
/      /  \
4      5    6
\     \
7     8
/       \
9         10

Output : 9
```

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Recursive approach to this problem is discussed here

For iterative approach, idea is similar to Method 2 of level order traversal

The idea is to traverse the tree iteratively and whenever a left tree node is pushed to queue, check if it is leaf node, if it’s leaf node, then update the result. Since we go level by level, the last stored leaf node is deepest one,

 `// CPP program to find deepest left leaf ` `// node of binary tree ` `#include ` `using` `namespace` `std; ` ` `  `// tree node ` `struct` `Node { ` `    ``int` `data; ` `    ``Node *left, *right; ` `}; ` ` `  `// returns a new tree Node ` `Node* newNode(``int` `data) ` `{ ` `    ``Node* temp = ``new` `Node(); ` `    ``temp->data = data; ` `    ``temp->left = temp->right = NULL; ` `    ``return` `temp; ` `} ` ` `  `// return the deepest left leaf node ` `// of binary tree ` `Node* getDeepestLeftLeafNode(Node* root) ` `{ ` `    ``if` `(!root) ` `        ``return` `NULL; ` ` `  `    ``// create a queue for level order traversal ` `    ``queue q; ` `    ``q.push(root); ` ` `  `    ``Node* result = NULL; ` ` `  `    ``// traverse until the queue is empty ` `    ``while` `(!q.empty()) { ` `        ``Node* temp = q.front(); ` `        ``q.pop(); ` ` `  `          `  `        ``// Since we go level by level, the last  ` `        ``// stored left leaf node is deepest one, ` `        ``if` `(temp->left) { ` `            ``q.push(temp->left); ` `            ``if` `(!temp->left->left && !temp->left->right) ` `                ``result = temp->left; ` `        ``} ` `         `  `        ``if` `(temp->right) ` `            ``q.push(temp->right); ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// driver program ` `int` `main() ` `{ ` `    ``// construct a tree ` `    ``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); ` `    ``root->right->right->right->right = newNode(10); ` ` `  `    ``Node* result = getDeepestLeftLeafNode(root); ` `    ``if` `(result) ` `        ``cout << ``"Deepest Left Leaf Node :: "`  `             ``<< result->data << endl; ` `    ``else` `        ``cout << ``"No result, left leaf not found\n"``; ` `    ``return` `0; ` `} `

 `// Java program to find deepest left leaf ` `// node of binary tree ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// tree node ` `static` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node left, right; ` `}; ` ` `  `// returns a new tree Node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} ` ` `  `// return the deepest left leaf node ` `// of binary tree ` `static` `Node getDeepestLeftLeafNode(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return` `null``; ` ` `  `    ``// create a queue for level order traversal ` `    ``Queue q = ``new` `LinkedList<>(); ` `    ``q.add(root); ` ` `  `    ``Node result = ``null``; ` ` `  `    ``// traverse until the queue is empty ` `    ``while` `(!q.isEmpty())  ` `    ``{ ` `        ``Node temp = q.peek(); ` `        ``q.remove(); ` ` `  `        ``// Since we go level by level, the last  ` `        ``// stored left leaf node is deepest one, ` `        ``if` `(temp.left != ``null``)  ` `        ``{ ` `            ``q.add(temp.left); ` `            ``if` `(temp.left.left == ``null` `&& ` `                ``temp.left.right == ``null``) ` `                ``result = temp.left; ` `        ``} ` `         `  `        ``if` `(temp.right != ``null``) ` `            ``q.add(temp.right); ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// construct a tree ` `    ``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``); ` `    ``root.right.right.right.right = newNode(``10``); ` ` `  `    ``Node result = getDeepestLeftLeafNode(root); ` `    ``if` `(result != ``null``) ` `        ``System.out.println(``"Deepest Left Leaf Node :: "` `+  ` `                                            ``result.data); ` `    ``else` `        ``System.out.println(``"No result, "` `+  ` `                   ``"left leaf not found"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

 `# Python3 program to find deepest  ` `# left leaf Binary search Tree ` ` `  `_MIN ``=` `-``2147483648` `_MAX ``=` `2147483648` ` `  `# Helper function that allocates a new  ` `# node with the given data and None  ` `# left and right poers.                                      ` `class` `newnode:  ` ` `  `    ``# Constructor to create a new node  ` `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None` ` `  `# utility function to return deepest ` `# left leaf node ` `def` `getDeepestLeftLeafNode(root) : ` ` `  `    ``if` `(``not` `root): ` `        ``return` `None` ` `  `    ``# create a queue for level ` `    ``# order traversal  ` `    ``q ``=` `[]  ` `    ``q.append(root)  ` ` `  `    ``result ``=` `None` ` `  `    ``# traverse until the queue is empty  ` `    ``while` `(``len``(q)):  ` `        ``temp ``=` `q[``0``]  ` `        ``q.pop(``0``)  ` ` `  `        ``if` `(temp.left): ` `            ``q.append(temp.left) ` `            ``if` `(``not` `temp.left.left ``and`  `                ``not` `temp.left.right):  ` `                ``result ``=` `temp.left  ` `         `  `        ``# Since we go level by level,  ` `        ``# the last stored right leaf ` `        ``# node is deepest one  ` `        ``if` `(temp.right):  ` `            ``q.append(temp.right)          ` `     `  `    ``return` `result ` ` `  `# Driver Code  ` `if` `__name__ ``=``=` `'__main__'``: ` `     `  `    ``# create a binary tree  ` `    ``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``) ` `    ``root.right.right.right.right ``=` `newnode(``10``)  ` ` `  `    ``result ``=` `getDeepestLeftLeafNode(root) ` `    ``if` `result: ` `        ``print``(``"Deepest Left Leaf Node ::"``, ` `                              ``result.data) ` `    ``else``: ` `        ``print``(``"No result, Left leaf not found"``) ` `         `  `# This code is contributed by ` `# Shubham Singh(SHUBHAMSINGH10) `

 `// C# program to find deepest left leaf ` `// node of binary tree ` `using` `System; ` `using` `System.Collections.Generic; ` `     `  `class` `GFG  ` `{ ` ` `  `// tree node ` `class` `Node ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node left, right; ` `}; ` ` `  `// returns a new tree Node ` `static` `Node newNode(``int` `data) ` `{ ` `    ``Node temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.left = temp.right = ``null``; ` `    ``return` `temp; ` `} ` ` `  `// return the deepest left leaf node ` `// of binary tree ` `static` `Node getDeepestLeftLeafNode(Node root) ` `{ ` `    ``if` `(root == ``null``) ` `        ``return` `null``; ` ` `  `    ``// create a queue for level order traversal ` `    ``Queue q = ``new` `Queue(); ` `    ``q.Enqueue(root); ` ` `  `    ``Node result = ``null``; ` ` `  `    ``// traverse until the queue is empty ` `    ``while` `(q.Count != 0)  ` `    ``{ ` `        ``Node temp = q.Peek(); ` `        ``q.Dequeue(); ` ` `  `        ``// Since we go level by level, the last  ` `        ``// stored left leaf node is deepest one, ` `        ``if` `(temp.left != ``null``)  ` `        ``{ ` `            ``q.Enqueue(temp.left); ` `            ``if` `(temp.left.left == ``null` `&& ` `                ``temp.left.right == ``null``) ` `                ``result = temp.left; ` `        ``} ` `        ``if` `(temp.right != ``null``) ` `            ``q.Enqueue(temp.right); ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `     `  `    ``// construct a tree ` `    ``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); ` `    ``root.right.right.right.right = newNode(10); ` ` `  `    ``Node result = getDeepestLeftLeafNode(root); ` `    ``if` `(result != ``null``) ` `        ``Console.WriteLine(``"Deepest Left Leaf Node :: "` `+  ` `                                           ``result.data); ` `    ``else` `        ``Console.WriteLine(``"No result, "` `+  ` `                  ``"left leaf not found"``); ` `    ``} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

Output:

```Deepest Left Leaf Node :: 9
```

Mandeep Singh

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : SHUBHAMSINGH10, Rajput-Ji

Article Tags :
Practice Tags :