Find min and max element in a binary tree

Minimum and maximum node in binary tree

Here given code implementation process.

// C program for 
// Find min and max element 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 dynamic node
	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 *newNode(int data)
{
	// Create dynamic node
	struct TreeNode *new_node = 
      (struct TreeNode *) malloc(sizeof(struct TreeNode));
	if (new_node != NULL)
	{
		//Set data and pointer values
		new_node->data = data;
		new_node->left = NULL;
		new_node->right = NULL;
	}
	else
	{
		//This is indicates, segmentation fault or memory overflow problem
		printf("Memory Overflow\n");
	}
	//return new node
	return new_node;
}
// Find the value of min and max node recursively
void findNode(struct TreeNode *node, 
              struct TreeNode **min, 
              struct TreeNode **max)
{
	if (node == NULL)
	{
		return;
	}
	if (( *min)->data > node->data)
	{
		// Change 
		*min = node;
	}
	if (( *max)->data < node->data)
	{
		*max = node;
	}
	// Visit left and right subtree
	findNode(node->left, min, max);
	findNode(node->right, min, max);
}
void minAndMax(struct TreeNode *root)
{
	if (root == NULL)
	{
		return;
	}
	// Assign first root of tree
	struct TreeNode *min = root;
	struct TreeNode *max = root;
	// Find node value
	findNode(root, & min, & max);
	// Display min and max node value
	printf(" Minimum : %d", min->data);
	printf("\n Maximum : %d\n", max->data);
	// Note that in case only one node then both 
	// printing the value of root node
}
int main(int argc, char
	const *argv[])
{
	struct BinaryTree *tree = newTree();
	/*
	             4                            
	           /   \    
	         -4     7    
	         / \     \               
	        2   3     12
	       /   / \    / 
	      1   10  8  15
	     /    /       \
	    3    9         13 

	    -----------------
	       Binary tree

	*/
	tree->root = newNode(4);
	tree->root->left = newNode(-4);
	tree->root->left->right = newNode(3);
	tree->root->left->right->left = newNode(10);
	tree->root->left->right->left->left = newNode(9);
	tree->root->left->right->right = newNode(8);
	tree->root->left->left = newNode(2);
	tree->root->left->left->left = newNode(1);
	tree->root->left->left->left->left = newNode(3);
	tree->root->right = newNode(7);
	tree->root->right->right = newNode(12);
	tree->root->right->right->left = newNode(15);
	tree->root->right->right->left->right = newNode(13);
	minAndMax(tree->root);
	return 0;
}

Output

 Minimum : -4
 Maximum : 15
/*
  Java program for
  Find min and max element 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 int min;
	public int max;
	public BinaryTree()
	{
		// Set initial tree root to null
		this.root = null;
		this.min = 0;
		this.max = 0;
	}
	// Find the value of min and max node recursively
	public void findNode(TreeNode node)
	{
		if (node == null)
		{
			return;
		}
		if (this.min > node.data)
		{
			// Change 
			this.min = node.data;
		}
		if (this.max < node.data)
		{
			max = node.data;
		}
		// Visit left and right subtree
		this.findNode(node.left);
		this.findNode(node.right);
	}
	public void minAndMax()
	{
		if (this.root == null)
		{
			return;
		}
		// Assign root value to min max
		this.min = this.root.data;
		this.max = this.root.data;
		// Find node value
		this.findNode(this.root);
		// Display min and max node value
		System.out.print(" Minimum : " + this.min);
		System.out.print("\n Maximum : " +  this.max + "\n");
	}
	public static void main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		/*
		         4                            
		       /   \    
		     -4     7    
		     / \     \               
		    2   3     12
		   /   / \    / 
		  1   10  8  15
		 /    /       \
		3    9         13 

		-----------------
		   Binary tree

		*/
		tree.root = new TreeNode(4);
		tree.root.left = new TreeNode(-4);
		tree.root.left.right = new TreeNode(3);
		tree.root.left.right.left = new TreeNode(10);
		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.left.left.left = new TreeNode(1);
		tree.root.left.left.left.left = new TreeNode(3);
		tree.root.right = new TreeNode(7);
		tree.root.right.right = new TreeNode(12);
		tree.root.right.right.left = new TreeNode(15);
		tree.root.right.right.left.right = new TreeNode(13);
		tree.minAndMax();
	}
}

Output

 Minimum : -4
 Maximum : 15
// Include header file
#include <iostream>
using namespace std;
/*
  C++ program for
  Find min and max element 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;
	int min;
	int max;
	BinaryTree()
	{
		this->root = NULL;
		this->min = 0;
		this->max = 0;
	}
	// Find the value of min and max node recursively
	void findNode(TreeNode *node)
	{
		if (node == NULL)
		{
			return;
		}
		if (this->min > node->data)
		{
			// Change
			this->min = node->data;
		}
		if (this->max < node->data)
		{
			this->max = node->data;
		}
		// Visit left and right subtree
		this->findNode(node->left);
		this->findNode(node->right);
	}
	void minAndMax()
	{
		if (this->root == NULL)
		{
			return;
		}
		// Assign root value to min max
		this->min = this->root->data;
		this->max = this->root->data;
		// Find node value
		this->findNode(this->root);
		// Display min and max node value
		cout << " Minimum : " << this->min;
		cout << "\n Maximum : " << this->max << "\n";
	}
};
int main()
{
	BinaryTree *tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	tree->root = new TreeNode(4);
	tree->root->left = new TreeNode(-4);
	tree->root->left->right = new TreeNode(3);
	tree->root->left->right->left = new TreeNode(10);
	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->left->left->left = new TreeNode(1);
	tree->root->left->left->left->left = new TreeNode(3);
	tree->root->right = new TreeNode(7);
	tree->root->right->right = new TreeNode(12);
	tree->root->right->right->left = new TreeNode(15);
	tree->root->right->right->left->right = new TreeNode(13);
	tree->minAndMax();
	return 0;
}

Output

 Minimum : -4
 Maximum : 15
// Include namespace system
using System;
/*
  Csharp program for
  Find min and max element 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 int min;
	public int max;
	public BinaryTree()
	{
		// Set initial tree root to null
		this.root = null;
		this.min = 0;
		this.max = 0;
	}
	// Find the value of min and max node recursively
	public void findNode(TreeNode node)
	{
		if (node == null)
		{
			return;
		}
		if (this.min > node.data)
		{
			// Change
			this.min = node.data;
		}
		if (this.max < node.data)
		{
			this.max = node.data;
		}
		// Visit left and right subtree
		this.findNode(node.left);
		this.findNode(node.right);
	}
	public void minAndMax()
	{
		if (this.root == null)
		{
			return;
		}
		// Assign root value to min max
		this.min = this.root.data;
		this.max = this.root.data;
		// Find node value
		this.findNode(this.root);
		// Display min and max node value
		Console.Write(" Minimum : " + this.min);
		Console.Write("\n Maximum : " + this.max + "\n");
	}
	public static void Main(String[] args)
	{
		BinaryTree tree = new BinaryTree();
		/*
		         4                            
		       /   \    
		     -4     7    
		     / \     \               
		    2   3     12
		   /   / \    / 
		  1   10  8  15
		 /    /       \
		3    9         13 
		-----------------
		   Binary tree
		*/
		tree.root = new TreeNode(4);
		tree.root.left = new TreeNode(-4);
		tree.root.left.right = new TreeNode(3);
		tree.root.left.right.left = new TreeNode(10);
		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.left.left.left = new TreeNode(1);
		tree.root.left.left.left.left = new TreeNode(3);
		tree.root.right = new TreeNode(7);
		tree.root.right.right = new TreeNode(12);
		tree.root.right.right.left = new TreeNode(15);
		tree.root.right.right.left.right = new TreeNode(13);
		tree.minAndMax();
	}
}

Output

 Minimum : -4
 Maximum : 15
package main
import "fmt"
/*
  Go program for
  Find min and max element in a binary tree
*/
// Binary Tree node
type TreeNode struct {
	data int
	left * TreeNode
	right * TreeNode
}
func getTreeNode(data int) * TreeNode {
	var me *TreeNode = &TreeNode {}
	// Set node value
	me.data = data
	me.left = nil
	me.right = nil
	return me
}
type BinaryTree struct {
	root * TreeNode
	min int
	max int
}
func getBinaryTree() * BinaryTree {
	var me *BinaryTree = &BinaryTree {}
	// Set initial tree root to null
	me.root = nil
	me.min = 0
	me.max = 0
	return me
}
// Find the value of min and max node recursively
func(this *BinaryTree) findNode(node * TreeNode) {
	if node == nil {
		return
	}
	if this.min > node.data {
		// Change
		this.min = node.data
	}
	if this.max < node.data {
		this.max = node.data
	}
	// Visit left and right subtree
	this.findNode(node.left)
	this.findNode(node.right)
}
func(this BinaryTree) minAndMax() {
	if this.root == nil {
		return
	}
	// Assign root value to min max
	this.min = this.root.data
	this.max = this.root.data
	// Find node value
	this.findNode(this.root)
	// Display min and max node value
	fmt.Print(" Minimum : ", this.min)
	fmt.Print("\n Maximum : ", this.max, "\n")
}
func main() {
	var tree * BinaryTree = getBinaryTree()
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	tree.root = getTreeNode(4)
	tree.root.left = getTreeNode(-4)
	tree.root.left.right = getTreeNode(3)
	tree.root.left.right.left = getTreeNode(10)
	tree.root.left.right.left.left = getTreeNode(9)
	tree.root.left.right.right = getTreeNode(8)
	tree.root.left.left = getTreeNode(2)
	tree.root.left.left.left = getTreeNode(1)
	tree.root.left.left.left.left = getTreeNode(3)
	tree.root.right = getTreeNode(7)
	tree.root.right.right = getTreeNode(12)
	tree.root.right.right.left = getTreeNode(15)
	tree.root.right.right.left.right = getTreeNode(13)
	tree.minAndMax()
}

Output

 Minimum : -4
 Maximum : 15
<?php
/*
  Php program for
  Find min and max element 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 $min;
	public $max;
	public	function __construct()
	{
		$this->root = NULL;
		$this->min = 0;
		$this->max = 0;
	}
	// Find the value of min and max node recursively
	public	function findNode($node)
	{
		if ($node == NULL)
		{
			return;
		}
		if ($this->min > $node->data)
		{
			// Change
			$this->min = $node->data;
		}
		if ($this->max < $node->data)
		{
			$this->max = $node->data;
		}
		// Visit left and right subtree
		$this->findNode($node->left);
		$this->findNode($node->right);
	}
	public	function minAndMax()
	{
		if ($this->root == NULL)
		{
			return;
		}
		// Assign root value to min max
		$this->min = $this->root->data;
		$this->max = $this->root->data;
		// Find node value
		$this->findNode($this->root);
		// Display min and max node value
		echo(" Minimum : ".$this->min);
		echo("\n Maximum : ".$this->max."\n");
	}
}

function main()
{
	$tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	$tree->root = new TreeNode(4);
	$tree->root->left = new TreeNode(-4);
	$tree->root->left->right = new TreeNode(3);
	$tree->root->left->right->left = new TreeNode(10);
	$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->left->left->left = new TreeNode(1);
	$tree->root->left->left->left->left = new TreeNode(3);
	$tree->root->right = new TreeNode(7);
	$tree->root->right->right = new TreeNode(12);
	$tree->root->right->right->left = new TreeNode(15);
	$tree->root->right->right->left->right = new TreeNode(13);
	$tree->minAndMax();
}
main();

Output

 Minimum : -4
 Maximum : 15
/*
  Node JS program for
  Find min and max element 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;
		this.min = 0;
		this.max = 0;
	}
	// Find the value of min and max node recursively
	findNode(node)
	{
		if (node == null)
		{
			return;
		}
		if (this.min > node.data)
		{
			// Change
			this.min = node.data;
		}
		if (this.max < node.data)
		{
			this.max = node.data;
		}
		// Visit left and right subtree
		this.findNode(node.left);
		this.findNode(node.right);
	}
	minAndMax()
	{
		if (this.root == null)
		{
			return;
		}
		// Assign root value to min max
		this.min = this.root.data;
		this.max = this.root.data;
		// Find node value
		this.findNode(this.root);
		// Display min and max node value
		process.stdout.write(" Minimum : " + this.min);
		process.stdout.write("\n Maximum : " + this.max + "\n");
	}
}

function main()
{
	var tree = new BinaryTree();
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	tree.root = new TreeNode(4);
	tree.root.left = new TreeNode(-4);
	tree.root.left.right = new TreeNode(3);
	tree.root.left.right.left = new TreeNode(10);
	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.left.left.left = new TreeNode(1);
	tree.root.left.left.left.left = new TreeNode(3);
	tree.root.right = new TreeNode(7);
	tree.root.right.right = new TreeNode(12);
	tree.root.right.right.left = new TreeNode(15);
	tree.root.right.right.left.right = new TreeNode(13);
	tree.minAndMax();
}
main();

Output

 Minimum : -4
 Maximum : 15
#  Python 3 program for
#  Find min and max element 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
		self.min = 0
		self.max = 0
	
	#  Find the value of min and max node recursively
	def findNode(self, node) :
		if (node == None) :
			return
		
		if (self.min > node.data) :
			#  Change
			self.min = node.data
		
		if (self.max < node.data) :
			self.max = node.data
		
		#  Visit left and right subtree
		self.findNode(node.left)
		self.findNode(node.right)
	
	def minAndMax(self) :
		if (self.root == None) :
			return
		
		#  Assign root value to min max
		self.min = self.root.data
		self.max = self.root.data
		#  Find node value
		self.findNode(self.root)
		#  Display min and max node value
		print(" Minimum : ", self.min, end = "")
		print("\n Maximum : ", self.max )
	

def main() :
	tree = BinaryTree()
	#          4                            
	#        /   \    
	#      -4     7    
	#      / \     \               
	#     2   3     12
	#    /   / \    / 
	#   1   10  8  15
	#  /    /       \
	# 3    9         13 
	# -----------------
	#   Binary tree
	tree.root = TreeNode(4)
	tree.root.left = TreeNode(-4)
	tree.root.left.right = TreeNode(3)
	tree.root.left.right.left = TreeNode(10)
	tree.root.left.right.left.left = TreeNode(9)
	tree.root.left.right.right = TreeNode(8)
	tree.root.left.left = TreeNode(2)
	tree.root.left.left.left = TreeNode(1)
	tree.root.left.left.left.left = TreeNode(3)
	tree.root.right = TreeNode(7)
	tree.root.right.right = TreeNode(12)
	tree.root.right.right.left = TreeNode(15)
	tree.root.right.right.left.right = TreeNode(13)
	tree.minAndMax()

if __name__ == "__main__": main()

Output

 Minimum :  -4
 Maximum :  15
#  Ruby program for
#  Find min and max element 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, :min, :max
	attr_accessor :root, :min, :max
	def initialize() 
		self.root = nil
		self.min = 0
		self.max = 0
	end

	#  Find the value of min and max node recursively
	def findNode(node) 
		if (node == nil) 
			return
		end

		if (self.min > node.data) 
			#  Change
			self.min = node.data
		end

		if (self.max < node.data) 
			self.max = node.data
		end

		#  Visit left and right subtree
		self.findNode(node.left)
		self.findNode(node.right)
	end

	def minAndMax() 
		if (self.root == nil) 
			return
		end

		#  Assign root value to min max
		self.min = self.root.data
		self.max = self.root.data
		#  Find node value
		self.findNode(self.root)
		#  Display min and max node value
		print(" Minimum : ", self.min)
		print("\n Maximum : ", self.max ,"\n")
	end

end

def main() 
	tree = BinaryTree.new()
	#          4                            
	#        /   \    
	#      -4     7    
	#      / \     \               
	#     2   3     12
	#    /   / \    / 
	#   1   10  8  15
	#  /    /       \
	# 3    9         13 
	# -----------------
	#   Binary tree
	tree.root = TreeNode.new(4)
	tree.root.left = TreeNode.new(-4)
	tree.root.left.right = TreeNode.new(3)
	tree.root.left.right.left = TreeNode.new(10)
	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.left.left.left = TreeNode.new(1)
	tree.root.left.left.left.left = TreeNode.new(3)
	tree.root.right = TreeNode.new(7)
	tree.root.right.right = TreeNode.new(12)
	tree.root.right.right.left = TreeNode.new(15)
	tree.root.right.right.left.right = TreeNode.new(13)
	tree.minAndMax()
end

main()

Output

 Minimum : -4
 Maximum : 15
/*
  Scala program for
  Find min and max element 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,
	var min: Int,
		var max: Int)
{
	def this()
	{
		this(null,0,0);
	}
	// Find the value of min and max node recursively
	def findNode(node: TreeNode): Unit = {
		if (node == null)
		{
			return;
		}
		if (this.min > node.data)
		{
			// Change
			this.min = node.data;
		}
		if (this.max < node.data)
		{
			max = node.data;
		}
		// Visit left and right subtree
		this.findNode(node.left);
		this.findNode(node.right);
	}
	def minAndMax(): Unit = {
		if (this.root == null)
		{
			return;
		}
		// Assign root value to min max
		this.min = this.root.data;
		this.max = this.root.data;
		// Find node value
		this.findNode(this.root);
		// Display min and max node value
		print(" Minimum : " + this.min);
		print("\n Maximum : " + this.max + "\n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var tree: BinaryTree = new BinaryTree();
		/*
		         4                            
		       /   \    
		     -4     7    
		     / \     \               
		    2   3     12
		   /   / \    / 
		  1   10  8  15
		 /    /       \
		3    9         13 
		-----------------
		   Binary tree
		*/
		tree.root = new TreeNode(4);
		tree.root.left = new TreeNode(-4);
		tree.root.left.right = new TreeNode(3);
		tree.root.left.right.left = new TreeNode(10);
		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.left.left.left = new TreeNode(1);
		tree.root.left.left.left.left = new TreeNode(3);
		tree.root.right = new TreeNode(7);
		tree.root.right.right = new TreeNode(12);
		tree.root.right.right.left = new TreeNode(15);
		tree.root.right.right.left.right = new TreeNode(13);
		tree.minAndMax();
	}
}

Output

 Minimum : -4
 Maximum : 15
/*
  Swift 4 program for
  Find min and max element 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? ;
	var min: Int;
	var max: Int;
	init()
	{
		self.root = nil;
		self.min = 0;
		self.max = 0;
	}
	// Find the value of min and max node recursively
	func findNode(_ node: TreeNode? )
	{
		if (node == nil)
		{
			return;
		}
		if (self.min > node!.data)
		{
			// Change
			self.min = node!.data;
		}
		if (self.max < node!.data)
		{
			self.max = node!.data;
		}
		// Visit left and right subtree
		self.findNode(node!.left);
		self.findNode(node!.right);
	}
	func minAndMax()
	{
		if (self.root == nil)
		{
			return;
		}
		// Assign root value to min max
		self.min = self.root!.data;
		self.max = self.root!.data;
		// Find node value
		self.findNode(self.root);
		// Display min and max node value
		print(" Minimum : ", self.min, terminator: "");
		print("\n Maximum : ", self.max );
	}
}
func main()
{
	let tree: BinaryTree = BinaryTree();
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	tree.root = TreeNode(4);
	tree.root!.left = TreeNode(-4);
	tree.root!.left!.right = TreeNode(3);
	tree.root!.left!.right!.left = TreeNode(10);
	tree.root!.left!.right!.left!.left = TreeNode(9);
	tree.root!.left!.right!.right = TreeNode(8);
	tree.root!.left!.left = TreeNode(2);
	tree.root!.left!.left!.left = TreeNode(1);
	tree.root!.left!.left!.left!.left = TreeNode(3);
	tree.root!.right = TreeNode(7);
	tree.root!.right!.right = TreeNode(12);
	tree.root!.right!.right!.left = TreeNode(15);
	tree.root!.right!.right!.left!.right = TreeNode(13);
	tree.minAndMax();
}
main();

Output

 Minimum :  -4
 Maximum :  15
/*
  Kotlin program for
  Find min and max element 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 ? ;
	var min: Int;
	var max: Int;
	constructor()
	{
		this.root = null;
		this.min = 0;
		this.max = 0;
	}
	// Find the value of min and max node recursively
	fun findNode(node: TreeNode?): Unit
	{
		if (node == null)
		{
			return;
		}
		if (this.min > node.data)
		{
			// Change
			this.min = node.data;
		}
		if (this.max < node.data)
		{
			this.max = node.data;
		}
		// Visit left and right subtree
		this.findNode(node.left);
		this.findNode(node.right);
	}
	fun minAndMax(): Unit
	{
		if (this.root == null)
		{
			return;
		}
		// Assign root value to min max
		this.min = this.root!!.data;
		this.max = this.root!!.data;
		// Find node value
		this.findNode(this.root);
		// Display min and max node value
		print(" Minimum : " + this.min);
		print("\n Maximum : " + this.max + "\n");
	}
}
fun main(args: Array < String > ): Unit
{
	val tree: BinaryTree = BinaryTree();
	/*
	         4                            
	       /   \    
	     -4     7    
	     / \     \               
	    2   3     12
	   /   / \    / 
	  1   10  8  15
	 /    /       \
	3    9         13 
	-----------------
	   Binary tree
	*/
	tree.root = TreeNode(4);
	tree.root?.left = TreeNode(-4);
	tree.root?.left?.right = TreeNode(3);
	tree.root?.left?.right?.left = TreeNode(10);
	tree.root?.left?.right?.left?.left = TreeNode(9);
	tree.root?.left?.right?.right = TreeNode(8);
	tree.root?.left?.left = TreeNode(2);
	tree.root?.left?.left?.left = TreeNode(1);
	tree.root?.left?.left?.left?.left = TreeNode(3);
	tree.root?.right = TreeNode(7);
	tree.root?.right?.right = TreeNode(12);
	tree.root?.right?.right?.left = TreeNode(15);
	tree.root?.right?.right?.left?.right = TreeNode(13);
	tree.minAndMax();
}

Output

 Minimum : -4
 Maximum : 15


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







© 2021, kalkicode.com, All rights reserved