Find maximum among all right nodes in Binary Tree

Here given code implementation process.

// Java program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	// Data value 
	public int data;
	// Indicates left and right subtree
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int data)
	{
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
public class BinaryTree
{
	public TreeNode root;
	public TreeNode result;
	public BinaryTree()
	{
		this.root = null;
		this.result = null;
	}
	public void findMaxRightNode(TreeNode node)
	{
		if (node != null)
		{
			if (node.right != null)
			{
              	// When current node have a right child exists
				if (this.result == null || 
                    this.result.data < node.right.data)
				{
                    // Update result node
					this.result = node.right;
				}
			}
			// Visit left subtree
			findMaxRightNode(node.left);
			// Visit right subtree
			findMaxRightNode(node.right);
		}
	}
	public void maxRightChild()
	{
		this.result = null;
		this.findMaxRightNode(this.root);
		if (this.result == null)
		{
			// When no right child
			System.out.println("None");
		}
		else
		{
			// Display calculated result
			System.out.println(this.result.data);
		}
	}
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		/*  Binary Tree
		    -----------------------
		          1
		         /  \
		        11   3
		       /    /  \
		      4    5    6   
		     / \    \    \  
		    8   7    12   -4
		       / \       
		     -2   9    
		*/
		// Add Binary tree nodes
		tree.root = new TreeNode(1);
		tree.root.left = new TreeNode(11);
		tree.root.right = new TreeNode(3);
		tree.root.right.right = new TreeNode(6);
		tree.root.right.right.right = new TreeNode(-4);
		tree.root.right.left = new TreeNode(5);
		tree.root.left.left = new TreeNode(4);
		tree.root.left.left.left = new TreeNode(8);
		tree.root.left.left.right = new TreeNode(7);
		tree.root.left.left.right.left = new TreeNode(-2);
		tree.root.left.left.right.right = new TreeNode(9);
		tree.root.right.left.right = new TreeNode(12);
		/*
		    
		          1          
		         /  \
		        11   3       
		       /    /  \
		      4    5    6    
		     / \    \    \   
		    8   7    12   -4  
		       / \   ↑   
		     -2   9      

		    ----------------------
		    Max right child node is : 12
		*/
		tree.maxRightChild();
	}
}

Output

// Include header file
#include <iostream>
using namespace std;
// C++ program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	public:
	// Data value
	int data;
	// Indicates left and right subtree
	TreeNode *left;
	TreeNode *right;
	TreeNode(int data)
	{
		this->data = data;
		this->left = NULL;
		this->right = NULL;
	}
};
class BinaryTree
{
	public: 
    TreeNode *root;
	TreeNode *result;
	BinaryTree()
	{
		this->root = NULL;
		this->result = NULL;
	}
	void findMaxRightNode(TreeNode *node)
	{
		if (node != NULL)
		{
			if (node->right != NULL)
			{
				// When current node have a right child exists
				if (this->result == NULL || 
                    this->result->data < node->right->data)
				{
					// Update result node
					this->result = node->right;
				}
			}
			// Visit left subtree
			this->findMaxRightNode(node->left);
			// Visit right subtree
			this->findMaxRightNode(node->right);
		}
	}
	void maxRightChild()
	{
		this->result = NULL;
		this->findMaxRightNode(this->root);
		if (this->result == NULL)
		{
			// When no right child
			cout << "None" << endl;
		}
		else
		{
			// Display calculated result
			cout << this->result->data << endl;
		}
	}
};
int main()
{
	BinaryTree *tree = new BinaryTree();
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	tree->root = new TreeNode(1);
	tree->root->left = new TreeNode(11);
	tree->root->right = new TreeNode(3);
	tree->root->right->right = new TreeNode(6);
	tree->root->right->right->right = new TreeNode(-4);
	tree->root->right->left = new TreeNode(5);
	tree->root->left->left = new TreeNode(4);
	tree->root->left->left->left = new TreeNode(8);
	tree->root->left->left->right = new TreeNode(7);
	tree->root->left->left->right->left = new TreeNode(-2);
	tree->root->left->left->right->right = new TreeNode(9);
	tree->root->right->left->right = new TreeNode(12);
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	tree->maxRightChild();
	return 0;
}

Output

package main
import "fmt"
// Go program for
// Find maximum among all right nodes in Binary Tree
type TreeNode struct {
	// Data value
	data int
	// Indicates left and right subtree
	left * TreeNode
	right * TreeNode
}
func getTreeNode(data int) * TreeNode {
	var me *TreeNode = &TreeNode {}
	me.data = data
	me.left = nil
	me.right = nil
	return me
}
type BinaryTree struct {
	root * TreeNode
	result * TreeNode
}
func getBinaryTree() * BinaryTree {
	var me *BinaryTree = &BinaryTree {}
	me.root = nil
	me.result = nil
	return me
}
func(this *BinaryTree) findMaxRightNode(node * TreeNode) {
	if node != nil {
		if node.right != nil {
			// When current node have a right child exists
			if this.result == nil || 
				this.result.data < node.right.data {
				// Update result node
				this.result = node.right
			}
		}
		// Visit left subtree
		this.findMaxRightNode(node.left)
		// Visit right subtree
		this.findMaxRightNode(node.right)
	}
}
func(this *BinaryTree) maxRightChild() {
	this.result = nil
	this.findMaxRightNode(this.root)
	if this.result == nil {
		// When no right child
		fmt.Println("None")
	} else {
		// Display calculated result
		fmt.Println(this.result.data)
	}
}
func main() {
	var tree * BinaryTree = getBinaryTree()
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	tree.root = getTreeNode(1)
	tree.root.left = getTreeNode(11)
	tree.root.right = getTreeNode(3)
	tree.root.right.right = getTreeNode(6)
	tree.root.right.right.right = getTreeNode(-4)
	tree.root.right.left = getTreeNode(5)
	tree.root.left.left = getTreeNode(4)
	tree.root.left.left.left = getTreeNode(8)
	tree.root.left.left.right = getTreeNode(7)
	tree.root.left.left.right.left = getTreeNode(-2)
	tree.root.left.left.right.right = getTreeNode(9)
	tree.root.right.left.right = getTreeNode(12)
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	tree.maxRightChild()
}

Output

// Include namespace system
using System;
// Csharp program for
// Find maximum among all right nodes in Binary Tree
public class TreeNode
{
	// Data value
	public int data;
	// Indicates left and right subtree
	public TreeNode left;
	public TreeNode right;
	public TreeNode(int data)
	{
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
public class BinaryTree
{
	public TreeNode root;
	public TreeNode result;
	public BinaryTree()
	{
		this.root = null;
		this.result = null;
	}
	public void findMaxRightNode(TreeNode node)
	{
		if (node != null)
		{
			if (node.right != null)
			{
				// When current node have a right child exists
				if (this.result == null || 
                    this.result.data < node.right.data)
				{
					// Update result node
					this.result = node.right;
				}
			}
			// Visit left subtree
			this.findMaxRightNode(node.left);
			// Visit right subtree
			this.findMaxRightNode(node.right);
		}
	}
	public void maxRightChild()
	{
		this.result = null;
		this.findMaxRightNode(this.root);
		if (this.result == null)
		{
			// When no right child
			Console.WriteLine("None");
		}
		else
		{
			// Display calculated result
			Console.WriteLine(this.result.data);
		}
	}
	public static void Main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		/*
		  Binary Tree
		    -----------------------
		          1
		         /  \
		        11   3
		       /    /  \
		      4    5    6   
		     / \    \    \  
		    8   7    12   -4
		       / \       
		     -2   9    
		*/
		// Add Binary tree nodes
		tree.root = new TreeNode(1);
		tree.root.left = new TreeNode(11);
		tree.root.right = new TreeNode(3);
		tree.root.right.right = new TreeNode(6);
		tree.root.right.right.right = new TreeNode(-4);
		tree.root.right.left = new TreeNode(5);
		tree.root.left.left = new TreeNode(4);
		tree.root.left.left.left = new TreeNode(8);
		tree.root.left.left.right = new TreeNode(7);
		tree.root.left.left.right.left = new TreeNode(-2);
		tree.root.left.left.right.right = new TreeNode(9);
		tree.root.right.left.right = new TreeNode(12);
		/*
		          1          
		         /  \
		        11   3       
		       /    /  \
		      4    5    6    
		     / \    \    \   
		    8   7    12   -4  
		       / \   ↑   
		     -2   9      
		    ----------------------
		    Max right child node is : 12
		*/
		tree.maxRightChild();
	}
}

Output

<?php
// Php program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	// Data value
	public $data;
	// Indicates left and right subtree
	public $left;
	public $right;
	public	function __construct($data)
	{
		$this->data = $data;
		$this->left = NULL;
		$this->right = NULL;
	}
}
class BinaryTree
{
	public $root;
	public $result;
	public	function __construct()
	{
		$this->root = NULL;
		$this->result = NULL;
	}
	public	function findMaxRightNode($node)
	{
		if ($node != NULL)
		{
			if ($node->right != NULL)
			{
				// When current node have a right child exists
				if ($this->result == NULL || 
                    $this->result->data < $node->right->data)
				{
					// Update result node
					$this->result = $node->right;
				}
			}
			// Visit left subtree
			$this->findMaxRightNode($node->left);
			// Visit right subtree
			$this->findMaxRightNode($node->right);
		}
	}
	public	function maxRightChild()
	{
		$this->result = NULL;
		$this->findMaxRightNode($this->root);
		if ($this->result == NULL)
		{
			// When no right child
			echo("None\n");
		}
		else
		{
			// Display calculated result
			echo($this->result->data."\n");
		}
	}
}

function main()
{
	$tree = new BinaryTree();
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	$tree->root = new TreeNode(1);
	$tree->root->left = new TreeNode(11);
	$tree->root->right = new TreeNode(3);
	$tree->root->right->right = new TreeNode(6);
	$tree->root->right->right->right = new TreeNode(-4);
	$tree->root->right->left = new TreeNode(5);
	$tree->root->left->left = new TreeNode(4);
	$tree->root->left->left->left = new TreeNode(8);
	$tree->root->left->left->right = new TreeNode(7);
	$tree->root->left->left->right->left = new TreeNode(-2);
	$tree->root->left->left->right->right = new TreeNode(9);
	$tree->root->right->left->right = new TreeNode(12);
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	$tree->maxRightChild();
}
main();

Output

// Node JS program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	constructor(data)
	{
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
class BinaryTree
{
	constructor()
	{
		this.root = null;
		this.result = null;
	}
	findMaxRightNode(node)
	{
		if (node != null)
		{
			if (node.right != null)
			{
				// When current node have a right child exists
				if (this.result == null || 
                    this.result.data < node.right.data)
				{
					// Update result node
					this.result = node.right;
				}
			}
			// Visit left subtree
			this.findMaxRightNode(node.left);
			// Visit right subtree
			this.findMaxRightNode(node.right);
		}
	}
	maxRightChild()
	{
		this.result = null;
		this.findMaxRightNode(this.root);
		if (this.result == null)
		{
			// When no right child
			console.log("None");
		}
		else
		{
			// Display calculated result
			console.log(this.result.data);
		}
	}
}

function main()
{
	var tree = new BinaryTree();
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	tree.root = new TreeNode(1);
	tree.root.left = new TreeNode(11);
	tree.root.right = new TreeNode(3);
	tree.root.right.right = new TreeNode(6);
	tree.root.right.right.right = new TreeNode(-4);
	tree.root.right.left = new TreeNode(5);
	tree.root.left.left = new TreeNode(4);
	tree.root.left.left.left = new TreeNode(8);
	tree.root.left.left.right = new TreeNode(7);
	tree.root.left.left.right.left = new TreeNode(-2);
	tree.root.left.left.right.right = new TreeNode(9);
	tree.root.right.left.right = new TreeNode(12);
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	tree.maxRightChild();
}
main();

Output

#  Python 3 program for
#  Find maximum among all right nodes in Binary Tree
class TreeNode :
	#  Data value
	#  Indicates left and right subtree
	def __init__(self, data) :
		self.data = data
		self.left = None
		self.right = None
	

class BinaryTree :
	def __init__(self) :
		self.root = None
		self.result = None
	
	def findMaxRightNode(self, node) :
		if (node != None) :
			if (node.right != None) :
				#  When current node have a right child exists
				if (self.result == None or self.result.data < node.right.data) :
					#  Update result node
					self.result = node.right
				
			
			#  Visit left subtree
			self.findMaxRightNode(node.left)
			#  Visit right subtree
			self.findMaxRightNode(node.right)
		
	
	def maxRightChild(self) :
		self.result = None
		self.findMaxRightNode(self.root)
		if (self.result == None) :
			#  When no right child
			print("None")
		else :
			#  Display calculated result
			print(self.result.data)
		
	

def main() :
	tree = BinaryTree()
	#  Binary Tree
	#    -----------------------
	#          1
	#         /  \
	#        11   3
	#       /    /  \
	#      4    5    6   
	#     / \    \    \  
	#    8   7    12   -4
	#       / \       
	#     -2   9    
	#  Add Binary tree nodes
	tree.root = TreeNode(1)
	tree.root.left = TreeNode(11)
	tree.root.right = TreeNode(3)
	tree.root.right.right = TreeNode(6)
	tree.root.right.right.right = TreeNode(-4)
	tree.root.right.left = TreeNode(5)
	tree.root.left.left = TreeNode(4)
	tree.root.left.left.left = TreeNode(8)
	tree.root.left.left.right = TreeNode(7)
	tree.root.left.left.right.left = TreeNode(-2)
	tree.root.left.left.right.right = TreeNode(9)
	tree.root.right.left.right = TreeNode(12)
	#          1          
	#         /  \
	#        11   3       
	#       /    /  \
	#      4    5    6    
	#     / \    \    \   
	#    8   7    12   -4  
	#       / \   ↑   
	#     -2   9      
	#    ----------------------
	#    Max right child node is : 12
	tree.maxRightChild()

if __name__ == "__main__": main()

Output

#  Ruby program for
#  Find maximum among all right nodes in Binary Tree
class TreeNode 
	# Define the accessor and reader of class TreeNode
	attr_reader :data, :left, :right
	attr_accessor :data, :left, :right
	#  Data value
	#  Indicates left and right subtree
	def initialize(data) 
		self.data = data
		self.left = nil
		self.right = nil
	end

end

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

	def findMaxRightNode(node) 
		if (node != nil) 
			if (node.right != nil) 
				#  When current node have a right child exists
				if (self.result == nil || 
                    self.result.data < node.right.data) 
					#  Update result node
					self.result = node.right
				end

			end

			#  Visit left subtree
			self.findMaxRightNode(node.left)
			#  Visit right subtree
			self.findMaxRightNode(node.right)
		end

	end

	def maxRightChild() 
		self.result = nil
		self.findMaxRightNode(self.root)
		if (self.result == nil) 
			#  When no right child
			print("None", "\n")
		else
 
			#  Display calculated result
			print(self.result.data, "\n")
		end

	end

end

def main() 
	tree = BinaryTree.new()
	#  Binary Tree
	#    -----------------------
	#          1
	#         /  \
	#        11   3
	#       /    /  \
	#      4    5    6   
	#     / \    \    \  
	#    8   7    12   -4
	#       / \       
	#     -2   9    
	#  Add Binary tree nodes
	tree.root = TreeNode.new(1)
	tree.root.left = TreeNode.new(11)
	tree.root.right = TreeNode.new(3)
	tree.root.right.right = TreeNode.new(6)
	tree.root.right.right.right = TreeNode.new(-4)
	tree.root.right.left = TreeNode.new(5)
	tree.root.left.left = TreeNode.new(4)
	tree.root.left.left.left = TreeNode.new(8)
	tree.root.left.left.right = TreeNode.new(7)
	tree.root.left.left.right.left = TreeNode.new(-2)
	tree.root.left.left.right.right = TreeNode.new(9)
	tree.root.right.left.right = TreeNode.new(12)
	#          1          
	#         /  \
	#        11   3       
	#       /    /  \
	#      4    5    6    
	#     / \    \    \   
	#    8   7    12   -4  
	#       / \   ↑   
	#     -2   9      
	#    ----------------------
	#    Max right child node is : 12
	tree.maxRightChild()
end

main()

Output

// Scala program for
// Find maximum among all right nodes in Binary Tree
class TreeNode(
	// Data value
	var data: Int,
		// Indicates left and right subtree
		var left: TreeNode,
			var right: TreeNode)
{
	def this(data: Int)
	{
		this(data, null, null);
	}
}
class BinaryTree(var root: TreeNode,
	var result: TreeNode)
{
	def this()
	{
		this(null, null);
	}
	def findMaxRightNode(node: TreeNode): Unit = {
		if (node != null)
		{
			if (node.right != null)
			{
				// When current node have a right child exists
				if (this.result == null || 
                    this.result.data < node.right.data)
				{
					// Update result node
					this.result = node.right;
				}
			}
			// Visit left subtree
			findMaxRightNode(node.left);
			// Visit right subtree
			findMaxRightNode(node.right);
		}
	}
	def maxRightChild(): Unit = {
		this.result = null;
		this.findMaxRightNode(this.root);
		if (this.result == null)
		{
			// When no right child
			println("None");
		}
		else
		{
			// Display calculated result
			println(this.result.data);
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var tree: BinaryTree = new BinaryTree();
		/*
		  Binary Tree
		    -----------------------
		          1
		         /  \
		        11   3
		       /    /  \
		      4    5    6   
		     / \    \    \  
		    8   7    12   -4
		       / \       
		     -2   9    
		*/
		// Add Binary tree nodes
		tree.root = new TreeNode(1);
		tree.root.left = new TreeNode(11);
		tree.root.right = new TreeNode(3);
		tree.root.right.right = new TreeNode(6);
		tree.root.right.right.right = new TreeNode(-4);
		tree.root.right.left = new TreeNode(5);
		tree.root.left.left = new TreeNode(4);
		tree.root.left.left.left = new TreeNode(8);
		tree.root.left.left.right = new TreeNode(7);
		tree.root.left.left.right.left = new TreeNode(-2);
		tree.root.left.left.right.right = new TreeNode(9);
		tree.root.right.left.right = new TreeNode(12);
		/*
		          1          
		         /  \
		        11   3       
		       /    /  \
		      4    5    6    
		     / \    \    \   
		    8   7    12   -4  
		       / \   ↑   
		     -2   9      
		    ----------------------
		    Max right child node is : 12
		*/
		tree.maxRightChild();
	}
}

Output

// Swift 4 program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	// Data value
	var data: Int;
	// Indicates left and right subtree
	var left: TreeNode? ;
	var right: TreeNode? ;
	init(_ data: Int)
	{
		self.data = data;
		self.left = nil;
		self.right = nil;
	}
}
class BinaryTree
{
	var root: TreeNode? ;
	var result: TreeNode? ;
	init()
	{
		self.root = nil;
		self.result = nil;
	}
	func findMaxRightNode(_ node: TreeNode? )
	{
		if (node  != nil)
		{
			if (node!.right  != nil)
			{
				// When current node have a right child exists
				if (self.result == nil || 
                    self.result!.data < node!.right!.data)
				{
					// Update result node
					self.result = node!.right;
				}
			}
			// Visit left subtree
			self.findMaxRightNode(node!.left);
			// Visit right subtree
			self.findMaxRightNode(node!.right);
		}
	}
	func maxRightChild()
	{
		self.result = nil;
		self.findMaxRightNode(self.root);
		if (self.result == nil)
		{
			// When no right child
			print("None");
		}
		else
		{
			// Display calculated result
			print(self.result!.data);
		}
	}
}
func main()
{
	let tree: BinaryTree = BinaryTree();
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	tree.root = TreeNode(1);
	tree.root!.left = TreeNode(11);
	tree.root!.right = TreeNode(3);
	tree.root!.right!.right = TreeNode(6);
	tree.root!.right!.right!.right = TreeNode(-4);
	tree.root!.right!.left = TreeNode(5);
	tree.root!.left!.left = TreeNode(4);
	tree.root!.left!.left!.left = TreeNode(8);
	tree.root!.left!.left!.right = TreeNode(7);
	tree.root!.left!.left!.right!.left = TreeNode(-2);
	tree.root!.left!.left!.right!.right = TreeNode(9);
	tree.root!.right!.left!.right = TreeNode(12);
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	tree.maxRightChild();
}
main();

Output

// Kotlin program for
// Find maximum among all right nodes in Binary Tree
class TreeNode
{
	// Data value
	var data: Int;
	// Indicates left and right subtree
	var left: TreeNode ? ;
	var right: TreeNode ? ;
	constructor(data: Int)
	{
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
class BinaryTree
{
	var root: TreeNode ? ;
	var result: TreeNode ? ;
	constructor()
	{
		this.root = null;
		this.result = null;
	}
	fun findMaxRightNode(node: TreeNode ? ): Unit
	{
		if (node != null)
		{
			if (node.right != null)
			{
				// When current node have a right child exists
				if (this.result == null || 
                    this.result!!.data < node.right!!.data)
				{
					// Update result node
					this.result = node.right;
				}
			}
			// Visit left subtree
			this.findMaxRightNode(node.left);
			// Visit right subtree
			this.findMaxRightNode(node.right);
		}
	}
	fun maxRightChild(): Unit
	{
		this.result = null;
		this.findMaxRightNode(this.root);
		if (this.result == null)
		{
			// When no right child
			println("None");
		}
		else
		{
			// Display calculated result
			println(this.result?.data);
		}
	}
}
fun main(args: Array < String > ): Unit
{
	val tree: BinaryTree = BinaryTree();
	/*
	  Binary Tree
	    -----------------------
	          1
	         /  \
	        11   3
	       /    /  \
	      4    5    6   
	     / \    \    \  
	    8   7    12   -4
	       / \       
	     -2   9    
	*/
	// Add Binary tree nodes
	tree.root = TreeNode(1);
	tree.root?.left = TreeNode(11);
	tree.root?.right = TreeNode(3);
	tree.root?.right?.right = TreeNode(6);
	tree.root?.right?.right?.right = TreeNode(-4);
	tree.root?.right?.left = TreeNode(5);
	tree.root?.left?.left = TreeNode(4);
	tree.root?.left?.left?.left = TreeNode(8);
	tree.root?.left?.left?.right = TreeNode(7);
	tree.root?.left?.left?.right?.left = TreeNode(-2);
	tree.root?.left?.left?.right?.right = TreeNode(9);
	tree.root?.right?.left?.right = TreeNode(12);
	/*
	          1          
	         /  \
	        11   3       
	       /    /  \
	      4    5    6    
	     / \    \    \   
	    8   7    12   -4  
	       / \   ↑   
	     -2   9      
	    ----------------------
	    Max right child node is : 12
	*/
	tree.maxRightChild();
}

Output

« Previous Next »

Binary Tree

Inorder Tree Traversal of a Binary Tree

Preorder Tree Traversal of a Binary Tree

Postorder Tree Traversal of a Binary Tree

Find height of binary tree

Clone a given binary tree

Morris traversal for Postorder

Morris traversal for Preorder

Morris traversal for Inorder

Calculate size of a tree

Delete a node in binary tree

Count leaf nodes in binary tree

Count internal nodes in binary tree

Check if all leaves are at same level

Find the max key in a binary tree

Print left view of a binary tree

Print right view of a binary tree

Print nodes in top view of binary tree

Print Bottom view of binary tree

Print Bottom-Left View of a Binary Tree

Print Bottom-Right View of a Binary Tree

Diagonal Traversal of Binary Tree

Diagonal Sum of a Binary Tree

Vertical Sum of given Binary Tree

Print vertical Traversal of binary tree

Euler tour of Binary Tree

Sum of all nodes in a binary tree

Inplace construct linked list into complete binary tree

Level order traversal line by line

Level order traversal in spiral form

Reverse Level Order Traversal of Binary Tree

Reverse Level Order traversal in spiral form

Count full nodes in a Binary tree

Boundary Traversal of binary tree

Convert binary tree to threaded binary tree

Lowest common ancestor in a binary tree

Sum of leaf nodes at minimum level

Density of binary tree in single Traversal

Find n-th node of inorder traversal in binary tree

Find n-th node in postorder traversal of a Binary Tree

Kth ancestor of a node in binary tree

Check Children Sum Property in a Binary Tree

Check if binary tree is Continuous Tree

Check if binary tree is Foldable Binary Tree

Check if given binary tree is complete binary tree or not

Check if two nodes are cousins in a Binary Tree

Count half nodes in a Binary Tree

Construct a tree from Inorder and Level order

Check whether a given binary tree is perfect or not

Convert a binary tree to Max Heap

Convert a given binary tree to Doubly Linked List

Construct Binary Tree from a Linked List

Convert binary tree to it's mirror

Construct Tree from given Inorder and Postorder

Binary tree down-right conversion

Delete a Binary Tree

Find ancestors of given node in a Binary Tree

Reverse the path from given node to root node

Find the sum of longest path from root to leaf node

Find the height of stratified perfect Binary Tree

Find the sum of maximum depth nodes of Binary Tree

Print all the nodes at certain level in a binary tree

Find next node of same level of given key in binary tree

Find the minimum node in a binary tree

Find the maximum sum from root to leaf path in Binary Tree

Print cousins of given node in a binary tree

Flatten binary tree in order of post-order traversal

Flatten a binary tree into linked list

Find top three elements in binary tree

Tilt of binary tree

Delete leaf node with given value

Convert given binary tree to its sum tree

Convert binary tree into min max product

Count odd paths in Binary Tree

Count Even paths in Binary Tree

Count of Fibonacci paths in a Binary tree

Size of binary tree without recursion

Sum of all left leaves nodes in a binary tree

Sum of all right leaves nodes in a binary tree

Find the sum of the node having child node x

Find sum of all nodes of the given perfect binary tree

Find the Sum of all full nodes in a Binary Tree

Print middle level of perfect binary tree

Find minimum depth of a Binary Tree

Check if two trees are mirror

Check For Symmetric Binary Tree

Find largest subtree sum in a tree

Sum of all nodes at given level in Binary Tree

Find nth node in preorder traversal

Count the number of visible nodes in Binary Tree

Level order traversal with direction change of given intervals

Replace each node in binary tree with the sum of its inorder predecessor and successor

Construct Special Binary Tree from given Inorder Traversal

Construct tree from given string parenthesis expression

Sum of heights of all every nodes in a binary tree

Print all subtrees of given sum in binary tree

Find subtree with given sum in a Binary Tree

Check if a given Binary Tree is Sumtree

Check whether a binary tree is a full binary tree or not

Root to leaf path sum equal to a given number

Find number of node exist in Euler Tour of Binary Tree

Print all palindromic paths of binary tree

Maximum path sum from leaf to leaf

Middle to top down level order traversal in binary tree

Longest zig zag path in a binary tree

Find mirror of a given node in binary tree

Construct a mirror tree from the given binary tree

Find the deepest node in binary tree

Deepest left leaf node in a binary tree

Get level of a node in a binary tree

Sum and product of internal nodes in binary tree

Pairwise swap leaf nodes in a binary tree

Product of all leaf nodes of binary tree

Print left and right leaf nodes in Binary Tree

Construct skewed binary tree

Sum of nodes having sum of subtrees of opposition parties

Clockwise spiral traversal of a binary tree

Anticlockwise spiral traversal of a binary tree

Reverse Clockwise spiral traversal of a binary tree

Reversal Anti clockwise spiral traversal of a binary tree

Maximum spiral sum in binary tree

Reverse inorder traversal using morris traversal

Check whether given binary is skewed binary tree

Print nodes at k distance from root

Find min and max element in a binary tree

Find the maximum leaf node in a binary tree

Find the minimum leaf node in a binary tree

Max average of subtree values in a given binary tree

Find the size of largest bst in a binary tree

Check if two trees are isomorphic or not

Inorder successor of a node in binary tree

Print all nodes at distance k from a given node

Print extreme nodes of each level of Binary Tree in alternate order

Sum of nodes in bottom view of Binary Tree

Sum of nodes in top view of binary tree efficiently

Maximum sum of leaf nodes among all levels of the given binary tree

Maximum sum of internal nodes among all levels of the given binary tree

Find maximum among all right nodes in Binary Tree

Find maximum among all left nodes in Binary Tree

Print the boundary nodes in each level of the binary tree

Check whether binary tree contains only one path

Construct a full Binary Tree from an array

Construct Binary Tree from given parent array

Construct Tree from given Inorder and Preorder

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

Name