Replace node with depth in a binary tree
Last Updated :
21 Mar, 2023
Given a binary tree, replace each node with its depth value. For example, consider the following tree. Root is at depth 0, change its value to 0 and next level nodes are at depth 1 and so on.
3 0
/ \ / \
2 5 == >; 1 1
/ \ / \
1 4 2 2
The idea is to traverse tree starting from root. While traversing pass depth of node as parameter. We can track depth by passing it as 0 for root and one-plus-current-depth for children.
Below is the implementation of the idea.
C++
#include<bits/stdc++.h>
using namespace std;
struct Node
{
int data;
struct Node *left, *right;
};
struct Node* newNode( int data)
{
Node *temp = new Node;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void replaceNode( struct Node *node, int level=0)
{
if (node == NULL)
return ;
node->data = level;
replaceNode(node->left, level+1);
replaceNode(node->right, level+1);
}
void printInorder( struct Node* node)
{
if (node == NULL)
return ;
printInorder(node->left);
cout << node->data << " " ;
printInorder(node->right);
}
int main()
{
struct Node *root = new struct Node;
root = newNode(3);
root->left = newNode(2);
root->right = newNode(5);
root->left->left = newNode(1);
root->left->right = newNode(4);
cout << "Before Replacing Nodes\n" ;
printInorder(root);
replaceNode(root);
cout << endl;
cout << "After Replacing Nodes\n" ;
printInorder(root);
return 0;
}
|
Java
class GfG {
static class Node
{
int data;
Node left, right;
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = null ;
temp.right = null ;
return temp;
}
static void replaceNode(Node node, int level)
{
if (node == null )
return ;
node.data = level;
replaceNode(node.left, level+ 1 );
replaceNode(node.right, level+ 1 );
}
static void printInorder(Node node)
{
if (node == null )
return ;
printInorder(node.left);
System.out.print(node.data + " " );
printInorder(node.right);
}
public static void main(String[] args)
{
Node root = new Node();
root = newNode( 3 );
root.left = newNode( 2 );
root.right = newNode( 5 );
root.left.left = newNode( 1 );
root.left.right = newNode( 4 );
System.out.println( "Before Replacing Nodes" );
printInorder(root);
replaceNode(root, 0 );
System.out.println();
System.out.println( "After Replacing Nodes" );
printInorder(root);
}
}
|
Python3
class newNode:
def __init__( self , data):
self .data = data
self .left = self .right = None
def replaceNode(node, level = 0 ):
if (node = = None ):
return
node.data = level
replaceNode(node.left, level + 1 )
replaceNode(node.right, level + 1 )
def printInorder(node):
if (node = = None ):
return
printInorder(node.left)
print (node.data, end = " " )
printInorder(node.right)
if __name__ = = '__main__' :
root = newNode( 3 )
root.left = newNode( 2 )
root.right = newNode( 5 )
root.left.left = newNode( 1 )
root.left.right = newNode( 4 )
print ( "Before Replacing Nodes" )
printInorder(root)
replaceNode(root)
print ()
print ( "After Replacing Nodes" )
printInorder(root)
|
C#
using System;
public class GfG
{
public class Node
{
public int data;
public Node left, right;
}
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = null ;
temp.right = null ;
return temp;
}
static void replaceNode(Node node, int level)
{
if (node == null )
return ;
node.data = level;
replaceNode(node.left, level + 1);
replaceNode(node.right, level + 1);
}
static void printInorder(Node node)
{
if (node == null )
return ;
printInorder(node.left);
Console.Write(node.data + " " );
printInorder(node.right);
}
public static void Main(String[] args)
{
Node root = new Node();
root = newNode(3);
root.left = newNode(2);
root.right = newNode(5);
root.left.left = newNode(1);
root.left.right = newNode(4);
Console.WriteLine( "Before Replacing Nodes" );
printInorder(root);
replaceNode(root, 0);
Console.WriteLine();
Console.WriteLine( "After Replacing Nodes" );
printInorder(root);
}
}
|
Javascript
<script>
class Node
{
constructor(data) {
this .left = null ;
this .right = null ;
this .data = data;
}
}
function newNode(data)
{
let temp = new Node(data);
return temp;
}
function replaceNode(node, level)
{
if (node == null )
return ;
node.data = level;
replaceNode(node.left, level+1);
replaceNode(node.right, level+1);
}
function printInorder(node)
{
if (node == null )
return ;
printInorder(node.left);
document.write(node.data + " " );
printInorder(node.right);
}
let root = new Node();
root = newNode(3);
root.left = newNode(2);
root.right = newNode(5);
root.left.left = newNode(1);
root.left.right = newNode(4);
document.write( "Before Replacing Nodes" + "</br>" );
printInorder(root);
replaceNode(root, 0);
document.write( "</br>" );
document.write( "</br>" );
document.write( "After Replacing Nodes" + "</br>" );
printInorder(root);
</script>
|
Output
Before Replacing Nodes
1 2 4 3 5
After Replacing Nodes
2 1 2 0 1
Time Complexity: O(n)
Space Complexity: If we don’t consider size of stack for function calls then O(1) otherwise O(h)
Iterative Approach(Using Queue data structure):
Follow the below steps to solve the above problem:
1) Perform level order traversal with the help of queue data structure.
2) At each level keep track to level(indexing 0) and replace all nodes data of current level to level value.
3) Print the Inorder traversal of resultant tree.
Below is the implementation of above approach:
C++
#include<bits/stdc++.h>
using namespace std;
struct Node{
int data;
struct Node *left, *right;
};
struct Node* newNode( int data){
Node* temp = new Node();
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
void replaceNode( struct Node* root){
if (root == NULL) return ;
queue<Node*> q;
int level = 0;
q.push(root);
while (!q.empty()){
int n = q.size();
for ( int i = 0; i<n; i++){
Node* front_node = q.front();
q.pop();
front_node->data = level;
if (front_node->left) q.push(front_node->left);
if (front_node->right) q.push(front_node->right);
}
level++;
}
}
void printInorder( struct Node* node){
if (node == NULL)
return ;
printInorder(node->left);
cout << node->data << " " ;
printInorder(node->right);
}
int main(){
struct Node *root = new struct Node;
root = newNode(3);
root->left = newNode(2);
root->right = newNode(5);
root->left->left = newNode(1);
root->left->right = newNode(4);
cout << "Before Replacing Nodes\n" ;
printInorder(root);
replaceNode(root);
cout << endl;
cout << "After Replacing Nodes\n" ;
printInorder(root);
return 0;
}
|
Java
import java.io.*;
import java.util.*;
class Node {
int data;
Node left, right;
}
class GFG {
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static void replaceNode(Node root)
{
if (root == null )
return ;
Queue<Node> q = new LinkedList<>();
int level = 0 ;
q.add(root);
while (!q.isEmpty()) {
int n = q.size();
for ( int i = 0 ; i < n; i++) {
Node frontNode = q.poll();
frontNode.data = level;
if (frontNode.left != null )
q.add(frontNode.left);
if (frontNode.right != null )
q.add(frontNode.right);
}
level++;
}
}
static void printInorder(Node node)
{
if (node == null )
return ;
printInorder(node.left);
System.out.print(node.data + " " );
printInorder(node.right);
}
public static void main(String[] args)
{
Node root = newNode( 3 );
root.left = newNode( 2 );
root.right = newNode( 5 );
root.left.left = newNode( 1 );
root.left.right = newNode( 4 );
System.out.println( "Before Replacing Nodes" );
printInorder(root);
replaceNode(root);
System.out.println();
System.out.println( "After Replacing Nodes" );
printInorder(root);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def replaceNode(root):
if root is None :
return
queue = []
level = 0
queue.append(root)
while queue:
n = len (queue)
for i in range (n):
front_node = queue.pop( 0 )
front_node.data = level
if front_node.left:
queue.append(front_node.left)
if front_node.right:
queue.append(front_node.right)
level + = 1
def printInorder(node):
if node is None :
return
printInorder(node.left)
print (node.data, end = " " )
printInorder(node.right)
if __name__ = = '__main__' :
root = Node( 3 )
root.left = Node( 2 )
root.right = Node( 5 )
root.left.left = Node( 1 )
root.left.right = Node( 4 )
print ( "Before Replacing Nodes" )
printInorder(root)
replaceNode(root)
print ()
print ( "After Replacing Nodes" )
printInorder(root)
|
C#
using System;
using System.Collections.Generic;
class Node {
public int data;
public Node left, right;
}
public class GFG {
static Node newNode( int data)
{
Node temp = new Node();
temp.data = data;
temp.left = temp.right = null ;
return temp;
}
static void replaceNode(Node root)
{
if (root == null )
return ;
Queue<Node> q = new Queue<Node>();
int level = 0;
q.Enqueue(root);
while (q.Count > 0) {
int n = q.Count;
for ( int i = 0; i < n; i++) {
Node frontNode = q.Dequeue();
frontNode.data = level;
if (frontNode.left != null )
q.Enqueue(frontNode.left);
if (frontNode.right != null )
q.Enqueue(frontNode.right);
}
level++;
}
}
static void printInorder(Node node)
{
if (node == null )
return ;
printInorder(node.left);
Console.Write(node.data + " " );
printInorder(node.right);
}
static public void Main()
{
Node root = newNode(3);
root.left = newNode(2);
root.right = newNode(5);
root.left.left = newNode(1);
root.left.right = newNode(4);
Console.WriteLine( "Before Replacing Nodes" );
printInorder(root);
replaceNode(root);
Console.WriteLine();
Console.WriteLine( "After Replacing Nodes" );
printInorder(root);
}
}
|
Javascript
class Node{
constructor(data){
this .data = data;
this .left = this .right = null ;
}
}
function newNode(data){
return new Node(data);
}
function replaceNode(root){
if (root == null ) return ;
let q = [];
let level = 0;
q.push(root);
while (q.length > 0){
let n = q.length;
for (let i = 0; i<n; i++){
let front_node = q.shift();
front_node.data = level;
if (front_node.left) q.push(front_node.left);
if (front_node.right) q.push(front_node.right);
}
level++;
}
}
function printInorder(node){
if (node == null ) return ;
printInorder(node.left);
console.log(node.data + " " );
printInorder(node.right);
}
let root = newNode(3);
root.left = newNode(2);
root.right = newNode(5);
root.left.left = newNode(1);
root.left.right = newNode(4);
console.log( "Before replacing Nodes : " );
printInorder(root);
replaceNode(root);
console.log( "After replacing Nodes : " );
printInorder(root);
|
Output
Before Replacing Nodes
1 2 4 3 5
After Replacing Nodes
2 1 2 0 1
Time Complexity: O(N) where N is the number of nodes in given binary tree
Auxiliary Space: O(N) due to queue data structure
Share your thoughts in the comments
Please Login to comment...