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++ 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(" "));
Mode of BST is 50
Time Complexity: O(N*logN)
Auxiliary Space: O(N)