Coefficient of Range in a Binary Tree
Last Updated :
13 Sep, 2021
Given a Binary Tree, the task is to find the Coefficient of Range in it.
Range is defined as the difference between the maximum and minimum value in a set of data and Coefficient of Range is the relative measure of the dispersion of the range. Suppose the maximum value in a data set is maxVal and minimum value is minVal then the coefficient of range can be defined as:
Coefficient of range = (maxVal – minVal)/(maxVal + minVal)
Consider the below Binary Tree:
For example, maximum in the above Binary Tree is 9 and minimum is 1 so coefficient of range is ((9 – 1)/ ( 9 + 1)) = 0.8.
Approach: In Binary Search Tree, we can find maximum by traversing right pointers until we reach rightmost node. But in Binary Tree, we must visit every node to figure out maximum. So the idea is to traverse the given tree and for every node return maximum of 3 values.
- Node’s data.
- Maximum in node’s left subtree.
- Maximum in node’s right subtree.
Similarly, find the minimum value in the Binary Tree and calculate the coefficient of range.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
float data;
struct Node *left, *right;
};
struct Node* newNode( float data)
{
struct Node* newnode = new Node();
newnode->data = data;
newnode->left = newnode->right = NULL;
return (newnode);
}
float findMax( struct Node* root)
{
if (root == NULL)
return INT_MIN;
float res = root->data;
float lres = findMax(root->left);
float rres = findMax(root->right);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
float findMin( struct Node* root)
{
if (root == NULL)
return INT_MAX;
float res = root->data;
float lres = findMin(root->left);
float rres = findMin(root->right);
if (lres < res)
res = lres;
if (rres < res)
res = rres;
return res;
}
float coefRange(Node* root)
{
float max = findMax(root);
float min = findMin(root);
return (max - min) / (max + min);
}
int main( void )
{
struct Node* root = newNode(2);
root->left = newNode(7);
root->right = newNode(5);
root->left->right = newNode(6);
root->left->right->left = newNode(1);
root->left->right->right = newNode(11);
root->right->right = newNode(9);
root->right->right->left = newNode(4);
cout << "Coefficient of Range is " << coefRange(root);
return 0;
}
|
Java
class GFG
{
static class Node
{
float data;
Node left, right;
};
static Node newNode( float data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
static float findMax(Node root)
{
if (root == null )
return Integer.MIN_VALUE;
float res = root.data;
float lres = findMax(root.left);
float rres = findMax(root.right);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
static float findMin(Node root)
{
if (root == null )
return Integer.MAX_VALUE;
float res = root.data;
float lres = findMin(root.left);
float rres = findMin(root.right);
if (lres < res)
res = lres;
if (rres < res)
res = rres;
return res;
}
static float coefRange(Node root)
{
float max = findMax(root);
float min = findMin(root);
return (max - min) / (max + min);
}
public static void main(String[] args)
{
Node root = newNode( 2 );
root.left = newNode( 7 );
root.right = newNode( 5 );
root.left.right = newNode( 6 );
root.left.right.left = newNode( 1 );
root.left.right.right = newNode( 11 );
root.right.right = newNode( 9 );
root.right.right.left = newNode( 4 );
System.out.print( "Coefficient of Range is " + coefRange(root));
}
}
|
Python3
from sys import maxsize
INT_MIN = - maxsize
INT_MAX = maxsize
class Node:
def __init__( self , data):
self .data = data
self .left = None
self .right = None
def findMax(root: Node) - > float :
if root is None :
return INT_MIN
res = root.data
lres = findMax(root.left)
rres = findMax(root.right)
if lres > res:
res = lres
if rres > res:
res = rres
return res
def findMin(root: Node) - > float :
if root is None :
return INT_MAX
res = root.data
lres = findMin(root.left)
rres = findMin(root.right)
if lres < res:
res = lres
if rres < res:
res = rres
return res
def coefRange(root: Node) - > float :
maxx = findMax(root)
minn = findMin(root)
return (maxx - minn) / (maxx + minn)
if __name__ = = "__main__" :
root = Node( 2 )
root.left = Node( 7 )
root.right = Node( 5 )
root.left.right = Node( 6 )
root.left.right.left = Node( 1 )
root.left.right.right = Node( 11 )
root.right.right = Node( 9 )
root.right.right.left = Node( 4 )
print ( "Coefficient of Range is" , coefRange(root))
|
C#
using System;
class GFG
{
class Node
{
public float data;
public Node left, right;
};
static Node newNode( float data)
{
Node node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
static float findMax(Node root)
{
if (root == null )
return int .MinValue;
float res = root.data;
float lres = findMax(root.left);
float rres = findMax(root.right);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
static float findMin(Node root)
{
if (root == null )
return int .MaxValue;
float res = root.data;
float lres = findMin(root.left);
float rres = findMin(root.right);
if (lres < res)
res = lres;
if (rres < res)
res = rres;
return res;
}
static float coefRange(Node root)
{
float max = findMax(root);
float min = findMin(root);
return (max - min) / (max + min);
}
public static void Main(String[] args)
{
Node root = newNode(2);
root.left = newNode(7);
root.right = newNode(5);
root.left.right = newNode(6);
root.left.right.left = newNode(1);
root.left.right.right = newNode(11);
root.right.right = newNode(9);
root.right.right.left = newNode(4);
Console.Write( "Coefficient of Range is " +
coefRange(root));
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .left = null ;
this .right = null ;
}
}
function newNode(data) {
var node = new Node();
node.data = data;
node.left = node.right = null ;
return (node);
}
function findMax(root) {
if (root == null )
return Number.MIN_VALUE;
var res = root.data;
var lres = findMax(root.left);
var rres = findMax(root.right);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
function findMin(root) {
if (root == null )
return Number.MAX_VALUE;
var res = root.data;
var lres = findMin(root.left);
var rres = findMin(root.right);
if (lres < res)
res = lres;
if (rres < res)
res = rres;
return res;
}
function coefRange(root) {
var max = findMax(root);
var min = findMin(root);
return (max - min) / (max + min);
}
var root = newNode(2);
root.left = newNode(7);
root.right = newNode(5);
root.left.right = newNode(6);
root.left.right.left = newNode(1);
root.left.right.right = newNode(11);
root.right.right = newNode(9);
root.right.right.left = newNode(4);
document.write( "Coefficient of Range is " + coefRange(root).toFixed(6));
</script>
|
Output:
Coefficient of Range is 0.833333
Time complexity : O(n) where n is the number of nodes.
Auxiliary Space: O(n)
Share your thoughts in the comments
Please Login to comment...