Find Mode in Binary Search tree
Last Updated :
22 Mar, 2023
Given a Binary Search Tree, find the mode of the tree.
Note: Mode is the value of the node which has the highest frequency in the binary search tree.
Examples:
Input:
100
/ \
50 160
/ \ / \
50 60 140 170
Output: The mode of BST is 50
Explanation: 50 is repeated 2 times, and all other nodes occur only once. Hence, the Mode is 50.
Input:
10
/ \
5 20
/ \
20 170
Output: The mode of BST is 20
Explanation: 20 is repeated 2 times, and all other nodes occur only once. Hence, the Mode is 20.
Approach: To solve the problem follow the below idea:
To solve this problem, we first find the in-order traversal of the BST and count the occurrences of each value in BST. We print the elements having a maximum frequency.
Steps that were to follow to implement the approach:
- Perform inorder traversal for the BST.
- Count the occurrences of values in a map and update the highest frequency.
- print the elements with the highest frequency.
Below is the implementation for the above approach:
C++
// C++ program to find the median of BST
#include <bits/stdc++.h>
using namespace std;
// A binary search tree Node has data,
// pointer to left child and a
// pointer to right child
struct Node {
int data;
struct Node *left, *right;
};
// Function to create a new BST node
struct Node* newNode(int item)
{
struct Node* temp = new Node;
temp->data = item;
temp->left = temp->right = NULL;
return temp;
}
// Function to insert a new node with
// given key in BST
struct Node* insert(struct Node* node, int key)
{
// If the tree is empty,
// return a new node
if (node == NULL)
return newNode(key);
// Otherwise, recur down the tree
if (key < node->data)
node->left = insert(node->left, key);
else if (key >= node->data)
node->right = insert(node->right, key);
// Return the (unchanged)
// node pointer
return node;
}
// Function to find inorder
// traversal of a BST
void inorderTraversal(Node* root, vector<int>& inorder)
{
// If the tree is empty,
// return NULL
if (root == NULL)
return;
// recur on left child
inorderTraversal(root->left, inorder);
// Push the data of node in inorder vector
inorder.push_back(root->data);
// recur on right child
inorderTraversal(root->right, inorder);
}
// Function to Mode of a BST
vector<int> findMode(Node* root)
{
vector<int> inorder;
// Find inorder traversal of BST
inorderTraversal(root, inorder);
int mx = INT_MIN;
unordered_map<int, int> mp;
// Counting occurrences of each
// element and updating
// maximum frequency
for (int i = 0; i < inorder.size(); i++) {
mp[inorder[i]]++;
mx = max(mp[inorder[i]], mx);
}
vector<int> res;
// Pushing the elements into vector
// with highest frequency
for (auto it : mp) {
if (it.second == mx)
res.push_back(it.first);
}
return res;
}
// Driver's code
int main()
{
/* Let us create following BST
100
/ \
50 160
/ \ / \
50 60 140 170 */
struct Node* root = NULL;
root = insert(root, 50);
insert(root, 60);
insert(root, 50);
insert(root, 160);
insert(root, 170);
insert(root, 140);
insert(root, 100);
// Function call
auto r = findMode(root);
cout << "Mode of BST is"
<< " ";
for (auto i : r) {
cout << i << " ";
}
return 0;
}
# Python program to find the mode of a BST
import sys
# A binary search tree Node has data,
# pointer to left child and a
# pointer to right child
class Node:
def __init__(self, key):
self.data = key
self.left = None
self.right = None
# Function to insert a new node with
# given key in BST
def insert(node, key):
# If the tree is empty,
# return a new node
if node is None:
return Node(key)
# Otherwise, recur down the tree
if key < node.data:
node.left = insert(node.left, key)
else:
node.right = insert(node.right, key)
# Return the (unchanged)
# node pointer
return node
# Function to find inorder
# traversal of a BST
def inorderTraversal(root, inorder):
# If the tree is not empty
if root:
# recur on left child
inorderTraversal(root.left, inorder)
# Push the data of node in inorder vector
inorder.append(root.data)
# recur on right child
inorderTraversal(root.right, inorder)
# Function to Mode of a BST
def findMode(root):
inorder = []
# Find inorder traversal of BST
inorderTraversal(root, inorder)
mp = {}
mx = -sys.maxsize - 1
# Counting occurrences of each
# element and updating
# maximum frequency
for i in range(len(inorder)):
mp[inorder[i]] = mp.get(inorder[i], 0) + 1
mx = max(mp[inorder[i]], mx)
res = []
# Pushing the elements into vector
# with highest frequency
for it in mp.items():
if it[1] == mx:
res.append(it[0])
return res
# Driver code
''' Let us create following BST
100
/ \
50 160
/ \ / \
50 60 140 170 '''
root = None
root = insert(root, 50)
insert(root, 60)
insert(root, 50)
insert(root, 160)
insert(root, 170)
insert(root, 140)
insert(root, 100)
# Function call
r = findMode(root)
print("Mode of BST is ", end="")
for i in r:
print(i, end=" ")
# This code is contributed by Prasad Kandekar(prasad264)
// Java program to find the mode of a BST
import java.util.*;
// A binary search tree Node has data,
// pointer to left child and a
// pointer to right child
class Node {
int data;
Node left, right;
// Function to create a new BST node
Node(int item)
{
data = item;
left = right = null;
}
}
class Main {
// Function to insert a new node with
// given key in BST
public static Node insert(Node node, int key)
{
// If the tree is empty,
// return a new node
if (node == null) {
return new Node(key);
}
// Otherwise, recur down the tree
if (key < node.data) {
node.left = insert(node.left, key);
}
else if (key >= node.data) {
node.right = insert(node.right, key);
}
// Return the (unchanged)
// node pointer
return node;
}
// Function to find inorder
// traversal of a BST
public static void
inorderTraversal(Node root, ArrayList<Integer> inorder)
{
// If the tree is empty,
// return NULL
if (root == null) {
return;
}
// recur on left child
inorderTraversal(root.left, inorder);
// Push the data of node in inorder list
inorder.add(root.data);
// recur on right child
inorderTraversal(root.right, inorder);
}
// Function to Mode of a BST
public static ArrayList<Integer> findMode(Node root)
{
ArrayList<Integer> inorder
= new ArrayList<Integer>();
// Find inorder traversal of BST
inorderTraversal(root, inorder);
int mx = Integer.MIN_VALUE;
HashMap<Integer, Integer> mp = new HashMap<>();
// Counting occurrences of each
// element and updating
// maximum frequency
for (int i = 0; i < inorder.size(); i++) {
mp.put(inorder.get(i),
mp.getOrDefault(inorder.get(i), 0) + 1);
mx = Math.max(mp.get(inorder.get(i)), mx);
}
ArrayList<Integer> res = new ArrayList<Integer>();
// Pushing the elements into list
// with highest frequency
for (Map.Entry<Integer, Integer> entry :
mp.entrySet()) {
if (entry.getValue() == mx) {
res.add(entry.getKey());
}
}
return res;
}
// Driver's code
public static void main(String[] args)
{
/* Let us create following BST
100
/ \
50 160
/ \ / \
50 60 140 170 */
Node root = null;
root = insert(root, 50);
insert(root, 60);
insert(root, 50);
insert(root, 160);
insert(root, 170);
insert(root, 140);
insert(root, 100);
// Function call
ArrayList<Integer> r = findMode(root);
System.out.print("Mode of BST is ");
for (Integer i : r) {
System.out.print(i + " ");
}
}
}
// C# program to find the median of BST
using System;
using System.Collections.Generic;
// A binary search tree Node has data,
// pointer to left child and a
// pointer to right child
class Node {
public int data;
public Node left, right;
// Constructor to create a new BST node
public Node(int item)
{
data = item;
left = right = null;
}
}
class GFG {
// Function to insert a new node with
// given key in BST
static Node Insert(Node node, int key)
{
// If the tree is empty,
// return a new node
if (node == null)
return new Node(key);
// Otherwise, recur down the tree
if (key < node.data)
node.left = Insert(node.left, key);
else if (key >= node.data)
node.right = Insert(node.right, key);
// Return the (unchanged)
// node pointer
return node;
}
// Function to find inorder
// traversal of a BST
static void InorderTraversal(Node root,
List<int> inorder)
{
// If the tree is empty,
// return NULL
if (root == null)
return;
// recur on left child
InorderTraversal(root.left, inorder);
// Push the data of node in inorder list
inorder.Add(root.data);
// recur on right child
InorderTraversal(root.right, inorder);
}
// Function to Mode of a BST
static List<int> FindMode(Node root)
{
List<int> inorder = new List<int>();
// Find inorder traversal of BST
InorderTraversal(root, inorder);
int mx = int.MinValue;
Dictionary<int, int> mp
= new Dictionary<int, int>();
// Counting occurrences of each
// element and updating
// maximum frequency
for (int i = 0; i < inorder.Count; i++) {
if (mp.ContainsKey(inorder[i]))
mp[inorder[i]]++;
else
mp.Add(inorder[i], 1);
mx = Math.Max(mp[inorder[i]], mx);
}
List<int> res = new List<int>();
// Pushing the elements into list
// with highest frequency
foreach(KeyValuePair<int, int> it in mp)
{
if (it.Value == mx)
res.Add(it.Key);
}
return res;
}
// Driver's code
static void Main()
{
/* Let us create following BST
100
/ \
50 160
/ \ / \
50 60 140 170 */
Node root = null;
root = Insert(root, 50);
Insert(root, 60);
Insert(root, 50);
Insert(root, 160);
Insert(root, 170);
Insert(root, 140);
Insert(root, 100);
// Function call
var r = FindMode(root);
Console.Write("Mode of BST is ");
foreach(int i in r) { Console.Write(i + " "); }
}
}
// A binary search tree Node has data,
// pointer to left child and a
// pointer to right child
class Node {
constructor(key) {
this.data = key;
this.left = null;
this.right = null;
}
}
// Function to insert a new node with
// given key in BST
function insert(node, key) {
// If the tree is empty,
// return a new node
if (node === null) {
return new Node(key);
}
// Otherwise, recur down the tree
if (key < node.data) {
node.left = insert(node.left, key);
} else {
node.right = insert(node.right, key);
}
// Return the (unchanged)
// node pointer
return node;
}
// Function to find inorder
// traversal of a BST
function inorderTraversal(root, inorder) {
// If the tree is not empty
if (root !== null) {
// recur on left child
inorderTraversal(root.left, inorder);
// Push the data of node in inorder vector
inorder.push(root.data);
// recur on right child
inorderTraversal(root.right, inorder);
}
}
// Function to Mode of a BST
function findMode(root) {
let inorder = [];
// Find inorder traversal of BST
inorderTraversal(root, inorder);
let mp = {};
let mx = -Infinity;
// Counting occurrences of each
// element and updating
// maximum frequency
for (let i = 0; i < inorder.length; i++) {
mp[inorder[i]] = (mp[inorder[i]] || 0) + 1;
mx = Math.max(mp[inorder[i]], mx);
}
let res = [];
// Pushing the elements into vector
// with highest frequency
for (let it in mp) {
if (mp[it] === mx) {
res.push(Number(it));
}
}
return res;
}
// Driver code
/* Let us create following BST
100
/ \
50 160
/ \ / \
50 60 140 170 */
let root = null;
root = insert(root, 50);
insert(root, 60);
insert(root, 50);
insert(root, 160);
insert(root, 170);
insert(root, 140);
insert(root, 100);
// Function call
let r = findMode(root);
console.log("Mode of BST is " + r.join(" "));
Time Complexity: O(N*logN)
Auxiliary Space: O(N)
Similar Reads
Search a node in Binary Tree
Given a Binary tree and a key. The task is to search and check if the given key exists in the binary tree or not. Examples: Input: Output: TrueInput: Output: False Approach:The idea is to use any of the tree traversals to traverse the tree and while traversing check if the current node matches with
7 min read
Minimum in a Binary Search Tree
Given the root of a Binary Search Tree. The task is to find the minimum valued element in this given BST. Example: Input: Output: 1Explanation: The minimum element in the given BST is 1. Input: Output: 2Explanation: The minimum element in the given BST is 2 Table of Content [Naive Approach] Using In
12 min read
Insertion in Binary Search Tree (BST)
Given a BST, the task is to insert a new node in this BST. Example: How to Insert a value in a Binary Search Tree:A new key is always inserted at the leaf by maintaining the property of the binary search tree. We start searching for a key from the root until we hit a leaf node. Once a leaf node is f
15+ min read
Inorder successor in Binary Tree
Given a binary tree and a node, the task is to find the inorder successor of this node. Inorder Successor of a node in the binary tree is the next node in the Inorder traversal of the Binary Tree. Inorder Successor is NULL for the last node in Inorder traversal. In the below diagram, inorder success
15 min read
Inorder predecessor in Binary Search Tree
Given a Binary Search Tree, the task is to find the In-Order predecessor of a given target key. In a Binary Search Tree (BST), the Inorder predecessor of a node is the previous node in the Inorder traversal of the BST. The Inorder predecessor is NULL for the first node in the Inorder traversal. Exam
10 min read
Introduction to Binary Search Tree
Binary Search Tree is a data structure used in computer science for organizing and storing data in a sorted manner. Binary search tree follows all properties of binary tree and for every nodes, its left subtree contains values less than the node and the right subtree contains values greater than the
3 min read
Deletion in Binary Search Tree (BST)
Given a BST, the task is to delete a node in this BST, which can be broken down into 3 scenarios: Case 1. Delete a Leaf Node in BST Case 2. Delete a Node with Single Child in BST Deleting a single child node is also simple in BST. Copy the child to the node and delete the node. Case 3. Delete a Node
10 min read
Optimal Binary Search Tree
Given a sorted array key [0.. n-1] of search keys and an array freq[0.. n-1] of frequency counts, where freq[i] is the number of searches for keys[i]. Construct a binary search tree of all keys such that the total cost of all the searches is as small as possible. The cost of a BST node is the level
15+ min read
Searching in Binary Search Tree (BST)
Given a BST, the task is to search a node in this BST. For searching a value in BST, consider it as a sorted array. Now we can easily perform search operation in BST using Binary Search Algorithm. Input: Root of the below BST Output: TrueExplanation: 8 is present in the BST as right child of rootInp
7 min read
Binary Search Tree
A Binary Search Tree (or BST) is a data structure used in computer science for organizing and storing data in a sorted manner. Each node in a Binary Search Tree has at most two children, a left child and a right child, with the left child containing values less than the parent node and the right chi
3 min read