Level Order Predecessor of a node in Binary Tree
Last Updated :
09 Sep, 2022
Given a binary tree and a node in the binary tree, find Levelorder Predecessor of the given node. That is, the node that appears before the given node in the level order traversal of the tree.
Note: The task is not just to print the data of the node, you have to return the complete node from the tree.
Examples:
Consider the following binary tree
20
/ \
10 26
/ \ / \
4 18 24 27
/ \
14 19
/ \
13 15
Levelorder traversal of given tree is:
20, 10, 26, 4, 18, 24, 27, 14, 19, 13, 15
Input : 19
Output : 14
Input : 4
Output : 26
Approach:
- Check if the root is NULL, that is tree is empty. If true then return NULL.
- Check if the given node is root. If true then there will be no predecessor of root, so return NULL.
- Otherwise, perform Level Order Traversal on the tree using a Queue and a temporary pointer prev to maintain the last node during the traversal.
- At every step of the level order traversal, check if the current node matches with the given node.
- If True, stop traversing any further and return the node stored in the pointer prev as it is the node accessed just before the current node during the traversal.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
struct Node *left, *right;
int value;
};
struct Node* newNode( int value)
{
Node* temp = new Node;
temp->left = temp->right = NULL;
temp->value = value;
return temp;
}
Node* levelOrderPredecessor(Node* root, Node* key)
{
if (root == NULL)
return NULL;
if (root == key) {
return NULL;
}
queue<Node*> q;
q.push(root);
Node* prev = NULL;
while (!q.empty()) {
Node* nd = q.front();
q.pop();
if (nd == key)
break ;
else
prev = nd;
if (nd->left != NULL) {
q.push(nd->left);
}
if (nd->right != NULL) {
q.push(nd->right);
}
}
return prev;
}
int main()
{
struct Node* root = newNode(20);
root->left = newNode(10);
root->left->left = newNode(4);
root->left->right = newNode(18);
root->right = newNode(26);
root->right->left = newNode(24);
root->right->right = newNode(27);
root->left->right->left = newNode(14);
root->left->right->left->left = newNode(13);
root->left->right->left->right = newNode(15);
root->left->right->right = newNode(19);
struct Node* key = root->left->right->right;
struct Node* res = levelOrderPredecessor(root, key);
if (res)
cout << "LevelOrder Predecessor of " << key->value
<< " is " << res->value;
else
cout << "LevelOrder Predecessor of " << key->value
<< " is "
<< "NULL" ;
return 0;
}
|
Java
import java.util.*;
class GfG {
static class Node {
Node left, right;
int value;
}
static Node newNode( int value)
{
Node temp = new Node();
temp.left = null ;
temp.right = null ;
temp.value = value;
return temp;
}
static Node levelOrderPredecessor(Node root, Node key)
{
if (root == null )
return null ;
if (root == key) {
return null ;
}
Queue<Node> q = new LinkedList<Node> ();
q.add(root);
Node prev = null ;
while (!q.isEmpty()) {
Node nd = q.peek();
q.remove();
if (nd == key)
break ;
else
prev = nd;
if (nd.left != null ) {
q.add(nd.left);
}
if (nd.right != null ) {
q.add(nd.right);
}
}
return prev;
}
public static void main(String[] args)
{
Node root = newNode( 20 );
root.left = newNode( 10 );
root.left.left = newNode( 4 );
root.left.right = newNode( 18 );
root.right = newNode( 26 );
root.right.left = newNode( 24 );
root.right.right = newNode( 27 );
root.left.right.left = newNode( 14 );
root.left.right.left.left = newNode( 13 );
root.left.right.left.right = newNode( 15 );
root.left.right.right = newNode( 19 );
Node key = root.left.right.right;
Node res = levelOrderPredecessor(root, key);
if (res != null )
System.out.println( "LevelOrder Predecessor of " + key.value + " is " + res.value);
else
System.out.println( "LevelOrder Predecessor of " + key.value+ " is null" );
}
}
|
Python3
class newNode:
def __init__( self , data):
self .value = data
self .left = None
self .right = self .parent = None
def levelOrderPredecessor(root, key) :
if (root = = None ) :
return None
if (root = = key):
return None
q = []
q.append(root)
prev = None
while ( len (q)):
nd = q[ 0 ]
q.pop( 0 )
if (nd = = key) :
break
else :
prev = nd
if (nd.left ! = None ):
q.append(nd.left)
if (nd.right ! = None ):
q.append(nd.right)
return prev
if __name__ = = '__main__' :
root = newNode( 20 )
root.left = newNode( 10 )
root.left.left = newNode( 4 )
root.left.right = newNode( 18 )
root.right = newNode( 26 )
root.right.left = newNode( 24 )
root.right.right = newNode( 27 )
root.left.right.left = newNode( 14 )
root.left.right.left.left = newNode( 13 )
root.left.right.left.right = newNode( 15 )
root.left.right.right = newNode( 19 )
key = root.left.right.right
res = levelOrderPredecessor(root, key)
if (res) :
print ( "LevelOrder Predecessor of" ,
key.value, "is" , res.value)
else :
print ( "LevelOrder Predecessor of" ,
key.value, "is" , "None" )
|
C#
using System;
using System.Collections.Generic;
class GfG
{
class Node
{
public Node left, right;
public int value;
}
static Node newNode( int value)
{
Node temp = new Node();
temp.left = null ;
temp.right = null ;
temp.value = value;
return temp;
}
static Node levelOrderPredecessor(Node root, Node key)
{
if (root == null )
return null ;
if (root == key)
{
return null ;
}
Queue<Node> q = new Queue<Node> ();
q.Enqueue(root);
Node prev = null ;
while (q.Count!=0)
{
Node nd = q.Peek();
q.Dequeue();
if (nd == key)
break ;
else
prev = nd;
if (nd.left != null )
{
q.Enqueue(nd.left);
}
if (nd.right != null )
{
q.Enqueue(nd.right);
}
}
return prev;
}
public static void Main(String[] args)
{
Node root = newNode(20);
root.left = newNode(10);
root.left.left = newNode(4);
root.left.right = newNode(18);
root.right = newNode(26);
root.right.left = newNode(24);
root.right.right = newNode(27);
root.left.right.left = newNode(14);
root.left.right.left.left = newNode(13);
root.left.right.left.right = newNode(15);
root.left.right.right = newNode(19);
Node key = root.left.right.right;
Node res = levelOrderPredecessor(root, key);
if (res != null )
Console.WriteLine( "LevelOrder Predecessor of " +
key.value + " is " + res.value);
else
Console.WriteLine( "LevelOrder Predecessor of " +
key.value+ " is null" );
}
}
|
Javascript
<script>
class Node
{
constructor(value) {
this .left = null ;
this .right = null ;
this .value = value;
}
}
function newNode(value)
{
let temp = new Node(value);
return temp;
}
function levelOrderPredecessor(root, key)
{
if (root == null )
return null ;
if (root == key) {
return null ;
}
let q = [];
q.push(root);
let prev = null ;
while (q.length > 0) {
let nd = q[0];
q.shift();
if (nd == key)
break ;
else
prev = nd;
if (nd.left != null ) {
q.push(nd.left);
}
if (nd.right != null ) {
q.push(nd.right);
}
}
return prev;
}
let root = newNode(20);
root.left = newNode(10);
root.left.left = newNode(4);
root.left.right = newNode(18);
root.right = newNode(26);
root.right.left = newNode(24);
root.right.right = newNode(27);
root.left.right.left = newNode(14);
root.left.right.left.left = newNode(13);
root.left.right.left.right = newNode(15);
root.left.right.right = newNode(19);
let key = root.left.right.right;
let res = levelOrderPredecessor(root, key);
if (res != null )
document.write( "LevelOrder Predecessor of " +
key.value + " is " + res.value);
else
document.write( "LevelOrder Predecessor of " +
key.value+ " is null" );
</script>
|
Output
LevelOrder Predecessor of 19 is 14
Complexity Analysis:
- Time Complexity: O(N), as we are using a while loop which will traverse N times, where N is the number of nodes in the tree.
- Auxiliary Space: O(N), as we are using extra space for the queue, which we are using for the level order traversal.
Share your thoughts in the comments
Please Login to comment...