Replace node with depth in a binary tree

Here given code implementation process.

// C program for
// Replace node with depth in a binary tree
#include <stdio.h>
#include <stdlib.h>

// Tree Node
struct TreeNode
{
	int data;
	struct TreeNode *left;
	struct TreeNode *right;
};
// Binary Tree
struct BinaryTree
{
	struct TreeNode *root;
};
// Create new tree
struct BinaryTree *newTree()
{
	// Create a dynamic tree 
	struct BinaryTree *tree = 
      (struct BinaryTree *) malloc(sizeof(struct BinaryTree));
	if (tree != NULL)
	{
		tree->root = NULL;
	}
	else
	{
		printf("Memory Overflow to Create tree Tree\n");
	}
	//return new tree
	return tree;
}
// This is creates and returns the new binary tree node
struct TreeNode *getNode(int data)
{
	// Create dynamic node
	struct TreeNode *node = 
      (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (node != NULL)
	{
		//Set data and pointer values
		node->data = data;
		node->left = NULL;
		node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault 
        // or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return node;
}
void preOrder(struct TreeNode *node)
{
	if (node != NULL)
	{
		// Print node value
		printf("  %d", node->data);
		// Visit left subtree
		preOrder(node->left);
		// Visit right subtree
		preOrder(node->right);
	}
}
void replaceByDepth(struct TreeNode *node, int depth)
{
	if (node != NULL)
	{
        // Change node value
		node->data = depth;
		// Visit left subtree
		replaceByDepth(node->left, depth + 1);
		// Visit right subtree
		replaceByDepth(node->right, depth + 1);
	}
}
int main(int argc, char const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree

	*/
	tree->root = getNode(4);
	tree->root->left = getNode(12);
	tree->root->left->right = getNode(3);
	tree->root->left->right->left = getNode(6);
	tree->root->left->right->left->left = getNode(9);
	tree->root->left->right->right = getNode(8);
	tree->root->left->left = getNode(2);
	tree->root->right = getNode(7);
	tree->root->right->right = getNode(1);
	tree->root->right->right->left = getNode(5);
	printf("\n Before replace by depth \n");
	preOrder(tree->root);
	// Update node value by depth
	replaceByDepth(tree->root, 0);
	printf("\n After replace by depth \n");
	preOrder(tree->root);
	return 0;
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
/*
    Java Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode
{
    public int data;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(int data)
    {
        // Set node value
        this.data = data;
        this.left = null;
        this.right = null;
    }
}
public class BinaryTree
{
    public TreeNode root;
    public BinaryTree()
    {
        // Set initial tree root to null
        this.root = null;
    }
    public void preOrder(TreeNode node)
    {
        if (node != null)
        {
            // Print node value
            System.out.print("  " + node.data );
            // Visit left subtree
            preOrder(node.left);
            // Visit right subtree
            preOrder(node.right);
        }
    }
    public void replaceByDepth(TreeNode node, int depth)
    {
        if (node != null)
        {
            // Change node value
            node.data = depth;
            // Visit left subtree
            replaceByDepth(node.left, depth + 1);
            // Visit right subtree
            replaceByDepth(node.right, depth + 1);
        }
    }
 
    public static void main(String[] args)
    {
        // Create new binary tree
        BinaryTree tree = new BinaryTree();
        /*
                 4                            
               /   \    
              12    7    
             / \      \               
            2   3      1
               / \    / 
              6   8  5
             /       
            9          
        -----------------
          Constructing binary tree

        */
        tree.root = new TreeNode(4);
        tree.root.left = new TreeNode(12);
        tree.root.left.right = new TreeNode(3);
        tree.root.left.right.left = new TreeNode(6);
        tree.root.left.right.left.left = new TreeNode(9);
        tree.root.left.right.right = new TreeNode(8);
        tree.root.left.left = new TreeNode(2);
        tree.root.right = new TreeNode(7);
        tree.root.right.right = new TreeNode(1);
        tree.root.right.right.left = new TreeNode(5);
        System.out.print("\n Before replace by depth \n");
        tree.preOrder(tree.root);
        // Update node value by depth
        tree.replaceByDepth(tree.root, 0);
        System.out.print("\n After replace by depth \n");
        tree.preOrder(tree.root);
    }
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
// Include header file
#include <iostream>
using namespace std;

/*
    C++ Program
    Replace node with depth in a binary tree
*/

// Binary Tree node
class TreeNode
{
	public: 
    int data;
	TreeNode *left;
	TreeNode *right;
	TreeNode(int data)
	{
		// Set node value
		this->data = data;
		this->left = NULL;
		this->right = NULL;
	}
};
class BinaryTree
{
	public: 
    TreeNode *root;
	BinaryTree()
	{
		this->root = NULL;
	}
	void preOrder(TreeNode *node)
	{
		if (node != NULL)
		{
			// Print node value
			cout << "  " << node->data;
			// Visit left subtree
			this->preOrder(node->left);
			// Visit right subtree
			this->preOrder(node->right);
		}
	}
	void replaceByDepth(TreeNode *node, int depth)
	{
		if (node != NULL)
		{
			// Change node value
			node->data = depth;
			// Visit left subtree
			this->replaceByDepth(node->left, depth + 1);
			// Visit right subtree
			this->replaceByDepth(node->right, depth + 1);
		}
	}
};
int main()
{
	// Create new binary tree
	BinaryTree *tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	tree->root = new TreeNode(4);
	tree->root->left = new TreeNode(12);
	tree->root->left->right = new TreeNode(3);
	tree->root->left->right->left = new TreeNode(6);
	tree->root->left->right->left->left = new TreeNode(9);
	tree->root->left->right->right = new TreeNode(8);
	tree->root->left->left = new TreeNode(2);
	tree->root->right = new TreeNode(7);
	tree->root->right->right = new TreeNode(1);
	tree->root->right->right->left = new TreeNode(5);
	cout << "\n Before replace by depth \n";
	tree->preOrder(tree->root);
	// Update node value by depth
	tree->replaceByDepth(tree->root, 0);
	cout << "\n After replace by depth \n";
	tree->preOrder(tree->root);
	return 0;
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
// Include namespace system
using System;
/*
    Csharp Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
public class TreeNode
{
	public int data;
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int data)
	{
		// Set node value
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
public class BinaryTree
{
	public TreeNode root;
	public BinaryTree()
	{
		// Set initial tree root to null
		this.root = null;
	}
	public void preOrder(TreeNode node)
	{
		if (node != null)
		{
			// Print node value
			Console.Write("  " + node.data);
			// Visit left subtree
			this.preOrder(node.left);
			// Visit right subtree
			this.preOrder(node.right);
		}
	}
	public void replaceByDepth(TreeNode node, int depth)
	{
		if (node != null)
		{
			// Change node value
			node.data = depth;
			// Visit left subtree
			this.replaceByDepth(node.left, depth + 1);
			// Visit right subtree
			this.replaceByDepth(node.right, depth + 1);
		}
	}
	public static void Main(String[] args)
	{
		// Create new binary tree
		BinaryTree tree = new BinaryTree();
		/*
		         4                            
		       /   \    
		      12    7    
		     / \      \               
		    2   3      1
		       / \    / 
		      6   8  5
		     /       
		    9          
		-----------------
		  Constructing binary tree
		*/
		tree.root = new TreeNode(4);
		tree.root.left = new TreeNode(12);
		tree.root.left.right = new TreeNode(3);
		tree.root.left.right.left = new TreeNode(6);
		tree.root.left.right.left.left = new TreeNode(9);
		tree.root.left.right.right = new TreeNode(8);
		tree.root.left.left = new TreeNode(2);
		tree.root.right = new TreeNode(7);
		tree.root.right.right = new TreeNode(1);
		tree.root.right.right.left = new TreeNode(5);
		Console.Write("\n Before replace by depth \n");
		tree.preOrder(tree.root);
		// Update node value by depth
		tree.replaceByDepth(tree.root, 0);
		Console.Write("\n After replace by depth \n");
		tree.preOrder(tree.root);
	}
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
<?php
/*
    Php Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode
{
	public $data;
	public $left;
	public $right;
	public	function __construct($data)
	{
		// Set node value
		$this->data = $data;
		$this->left = NULL;
		$this->right = NULL;
	}
}
class BinaryTree
{
	public $root;
	public	function __construct()
	{
		$this->root = NULL;
	}
	public	function preOrder($node)
	{
		if ($node != NULL)
		{
			// Print node value
			echo("  ".$node->data);
			// Visit left subtree
			$this->preOrder($node->left);
			// Visit right subtree
			$this->preOrder($node->right);
		}
	}
	public	function replaceByDepth($node, $depth)
	{
		if ($node != NULL)
		{
			// Change node value
			$node->data = $depth;
			// Visit left subtree
			$this->replaceByDepth($node->left, $depth + 1);
			// Visit right subtree
			$this->replaceByDepth($node->right, $depth + 1);
		}
	}
}

function main()
{
	// Create new binary tree
	$tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	$tree->root = new TreeNode(4);
	$tree->root->left = new TreeNode(12);
	$tree->root->left->right = new TreeNode(3);
	$tree->root->left->right->left = new TreeNode(6);
	$tree->root->left->right->left->left = new TreeNode(9);
	$tree->root->left->right->right = new TreeNode(8);
	$tree->root->left->left = new TreeNode(2);
	$tree->root->right = new TreeNode(7);
	$tree->root->right->right = new TreeNode(1);
	$tree->root->right->right->left = new TreeNode(5);
	echo("\n Before replace by depth \n");
	$tree->preOrder($tree->root);
	// Update node value by depth
	$tree->replaceByDepth($tree->root, 0);
	echo("\n After replace by depth \n");
	$tree->preOrder($tree->root);
}
main();

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
/*
    Node JS Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode
{
	constructor(data)
	{
		// Set node value
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
class BinaryTree
{
	constructor()
	{
		this.root = null;
	}
	preOrder(node)
	{
		if (node != null)
		{
			// Print node value
			process.stdout.write("  " + node.data);
			// Visit left subtree
			this.preOrder(node.left);
			// Visit right subtree
			this.preOrder(node.right);
		}
	}
	replaceByDepth(node, depth)
	{
		if (node != null)
		{
			// Change node value
			node.data = depth;
			// Visit left subtree
			this.replaceByDepth(node.left, depth + 1);
			// Visit right subtree
			this.replaceByDepth(node.right, depth + 1);
		}
	}
}

function main()
{
	// Create new binary tree
	var tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	tree.root = new TreeNode(4);
	tree.root.left = new TreeNode(12);
	tree.root.left.right = new TreeNode(3);
	tree.root.left.right.left = new TreeNode(6);
	tree.root.left.right.left.left = new TreeNode(9);
	tree.root.left.right.right = new TreeNode(8);
	tree.root.left.left = new TreeNode(2);
	tree.root.right = new TreeNode(7);
	tree.root.right.right = new TreeNode(1);
	tree.root.right.right.left = new TreeNode(5);
	process.stdout.write("\n Before replace by depth \n");
	tree.preOrder(tree.root);
	// Update node value by depth
	tree.replaceByDepth(tree.root, 0);
	process.stdout.write("\n After replace by depth \n");
	tree.preOrder(tree.root);
}
main();

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
#    Python 3 Program
#    Replace node with depth in a binary tree

#  Binary Tree node
class TreeNode :
	def __init__(self, data) :
		#  Set node value
		self.data = data
		self.left = None
		self.right = None
	

class BinaryTree :
	def __init__(self) :
		self.root = None
	
	def preOrder(self, node) :
		if (node != None) :
			#  Print node value
			print("  ", node.data, end = "")
			#  Visit left subtree
			self.preOrder(node.left)
			#  Visit right subtree
			self.preOrder(node.right)
		
	
	def replaceByDepth(self, node, depth) :
		if (node != None) :
			#  Change node value
			node.data = depth
			#  Visit left subtree
			self.replaceByDepth(node.left, depth + 1)
			#  Visit right subtree
			self.replaceByDepth(node.right, depth + 1)
		
	

def main() :
	#  Create new binary tree
	tree = BinaryTree()
	#         4                            
	#       /   \    
	#      12    7    
	#     / \      \               
	#    2   3      1
	#       / \    / 
	#      6   8  5
	#     /       
	#    9          
	# -----------------
	#  Constructing binary tree
	tree.root = TreeNode(4)
	tree.root.left = TreeNode(12)
	tree.root.left.right = TreeNode(3)
	tree.root.left.right.left = TreeNode(6)
	tree.root.left.right.left.left = TreeNode(9)
	tree.root.left.right.right = TreeNode(8)
	tree.root.left.left = TreeNode(2)
	tree.root.right = TreeNode(7)
	tree.root.right.right = TreeNode(1)
	tree.root.right.right.left = TreeNode(5)
	print("\n Before replace by depth ")
	tree.preOrder(tree.root)
	#  Update node value by depth
	tree.replaceByDepth(tree.root, 0)
	print("\n After replace by depth ")
	tree.preOrder(tree.root)

if __name__ == "__main__": main()

input

 Before replace by depth
   4   12   2   3   6   9   8   7   1   5
 After replace by depth
   0   1   2   2   3   4   3   1   2   3
#    Ruby Program
#    Replace node with depth in a binary tree

#  Binary Tree node
class TreeNode 
	# Define the accessor and reader of class TreeNode
	attr_reader :data, :left, :right
	attr_accessor :data, :left, :right
	def initialize(data) 
		#  Set node value
		self.data = data
		self.left = nil
		self.right = nil
	end

end

class BinaryTree 
	# Define the accessor and reader of class BinaryTree
	attr_reader :root
	attr_accessor :root
	def initialize() 
		self.root = nil
	end

	def preOrder(node) 
		if (node != nil) 
			#  Print node value
			print("  ", node.data)
			#  Visit left subtree
			self.preOrder(node.left)
			#  Visit right subtree
			self.preOrder(node.right)
		end

	end

	def replaceByDepth(node, depth) 
		if (node != nil) 
			#  Change node value
			node.data = depth
			#  Visit left subtree
			self.replaceByDepth(node.left, depth + 1)
			#  Visit right subtree
			self.replaceByDepth(node.right, depth + 1)
		end

	end

end

def main() 
	#  Create new binary tree
	tree = BinaryTree.new()
	#         4                            
	#       /   \    
	#      12    7    
	#     / \      \               
	#    2   3      1
	#       / \    / 
	#      6   8  5
	#     /       
	#    9          
	# -----------------
	#  Constructing binary tree
	tree.root = TreeNode.new(4)
	tree.root.left = TreeNode.new(12)
	tree.root.left.right = TreeNode.new(3)
	tree.root.left.right.left = TreeNode.new(6)
	tree.root.left.right.left.left = TreeNode.new(9)
	tree.root.left.right.right = TreeNode.new(8)
	tree.root.left.left = TreeNode.new(2)
	tree.root.right = TreeNode.new(7)
	tree.root.right.right = TreeNode.new(1)
	tree.root.right.right.left = TreeNode.new(5)
	print("\n Before replace by depth \n")
	tree.preOrder(tree.root)
	#  Update node value by depth
	tree.replaceByDepth(tree.root, 0)
	print("\n After replace by depth \n")
	tree.preOrder(tree.root)
end

main()

input

 Before replace by depth 
  4  12  2  3  6  9  8  7  1  5
 After replace by depth 
  0  1  2  2  3  4  3  1  2  3
/*
    Scala Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode(var data: Int,
	var left: TreeNode,
		var right: TreeNode)
{
	def this(data: Int)
	{
		// Set node value
		this(data,null,null);
	}
}
class BinaryTree(var root: TreeNode)
{
	def this()
	{
		this(null);
	}
	def preOrder(node: TreeNode): Unit = {
		if (node != null)
		{
			// Print node value
			print("  " + node.data);
			// Visit left subtree
			preOrder(node.left);
			// Visit right subtree
			preOrder(node.right);
		}
	}
	def replaceByDepth(node: TreeNode, depth: Int): Unit = {
		if (node != null)
		{
			// Change node value
			node.data = depth;
			// Visit left subtree
			replaceByDepth(node.left, depth + 1);
			// Visit right subtree
			replaceByDepth(node.right, depth + 1);
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		// Create new binary tree
		var tree: BinaryTree = new BinaryTree();
		/*
		         4                            
		       /   \    
		      12    7    
		     / \      \               
		    2   3      1
		       / \    / 
		      6   8  5
		     /       
		    9          
		-----------------
		  Constructing binary tree
		*/
		tree.root = new TreeNode(4);
		tree.root.left = new TreeNode(12);
		tree.root.left.right = new TreeNode(3);
		tree.root.left.right.left = new TreeNode(6);
		tree.root.left.right.left.left = new TreeNode(9);
		tree.root.left.right.right = new TreeNode(8);
		tree.root.left.left = new TreeNode(2);
		tree.root.right = new TreeNode(7);
		tree.root.right.right = new TreeNode(1);
		tree.root.right.right.left = new TreeNode(5);
		print("\n Before replace by depth \n");
		tree.preOrder(tree.root);
		// Update node value by depth
		tree.replaceByDepth(tree.root, 0);
		print("\n After replace by depth \n");
		tree.preOrder(tree.root);
	}
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3
/*
    Swift 4 Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode
{
	var data: Int;
	var left: TreeNode? ;
	var right: TreeNode? ;
	init(_ data: Int)
	{
		// Set node value
		self.data = data;
		self.left = nil;
		self.right = nil;
	}
}
class BinaryTree
{
	var root: TreeNode? ;
	init()
	{
		self.root = nil;
	}
	func preOrder(_ node: TreeNode? )
	{
		if (node  != nil)
		{
			// Print node value
			print("  ", node!.data, terminator: "");
			// Visit left subtree
			self.preOrder(node!.left);
			// Visit right subtree
			self.preOrder(node!.right);
		}
	}
	func replaceByDepth(_ node: TreeNode? , _ depth : Int)
	{
		if (node  != nil)
		{
			// Change node value
			node!.data = depth;
			// Visit left subtree
			self.replaceByDepth(node!.left, depth + 1);
			// Visit right subtree
			self.replaceByDepth(node!.right, depth + 1);
		}
	}
}
func main()
{
	// Create new binary tree
	let tree = BinaryTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	tree.root = TreeNode(4);
	tree.root!.left = TreeNode(12);
	tree.root!.left!.right = TreeNode(3);
	tree.root!.left!.right!.left = TreeNode(6);
	tree.root!.left!.right!.left!.left = TreeNode(9);
	tree.root!.left!.right!.right = TreeNode(8);
	tree.root!.left!.left = TreeNode(2);
	tree.root!.right = TreeNode(7);
	tree.root!.right!.right = TreeNode(1);
	tree.root!.right!.right!.left = TreeNode(5);
	print("\n Before replace by depth ");
	tree.preOrder(tree.root);
	// Update node value by depth
	tree.replaceByDepth(tree.root, 0);
	print("\n After replace by depth ");
	tree.preOrder(tree.root);
}
main();

input

 Before replace by depth
   4   12   2   3   6   9   8   7   1   5
 After replace by depth
   0   1   2   2   3   4   3   1   2   3
/*
    Kotlin Program
    Replace node with depth in a binary tree
*/
// Binary Tree node
class TreeNode
{
	var data: Int;
	var left: TreeNode ? ;
	var right: TreeNode ? ;
	constructor(data: Int)
	{
		// Set node value
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
class BinaryTree
{
	var root: TreeNode ? ;
	constructor()
	{
		this.root = null;
	}
	fun preOrder(node: TreeNode ? ): Unit
	{
		if (node != null)
		{
			// Print node value
			print("  " + node.data);
			// Visit left subtree
			this.preOrder(node.left);
			// Visit right subtree
			this.preOrder(node.right);
		}
	}
	fun replaceByDepth(node: TreeNode ? , depth : Int): Unit
	{
		if (node != null)
		{
			// Change node value
			node.data = depth;
			// Visit left subtree
			this.replaceByDepth(node.left, depth + 1);
			// Visit right subtree
			this.replaceByDepth(node.right, depth + 1);
		}
	}
}
fun main(args: Array < String > ): Unit
{
	// Create new binary tree
	val tree: BinaryTree = BinaryTree();
	/*
	         4                            
	       /   \    
	      12    7    
	     / \      \               
	    2   3      1
	       / \    / 
	      6   8  5
	     /       
	    9          
	-----------------
	  Constructing binary tree
	*/
	tree.root = TreeNode(4);
	tree.root?.left = TreeNode(12);
	tree.root?.left?.right = TreeNode(3);
	tree.root?.left?.right?.left = TreeNode(6);
	tree.root?.left?.right?.left?.left = TreeNode(9);
	tree.root?.left?.right?.right = TreeNode(8);
	tree.root?.left?.left = TreeNode(2);
	tree.root?.right = TreeNode(7);
	tree.root?.right?.right = TreeNode(1);
	tree.root?.right?.right?.left = TreeNode(5);
	print("\n Before replace by depth \n");
	tree.preOrder(tree.root);
	// Update node value by depth
	tree.replaceByDepth(tree.root, 0);
	print("\n After replace by depth \n");
	tree.preOrder(tree.root);
}

input

 Before replace by depth
  4  12  2  3  6  9  8  7  1  5
 After replace by depth
  0  1  2  2  3  4  3  1  2  3



Comment

Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment




© 2022, kalkicode.com, All rights reserved