Find maximum count of duplicate nodes in a Binary Search Tree
Last Updated :
16 Aug, 2021
Given a Binary Search Tree (BST) with duplicates, find the node (the most frequently occurred element) in the given BST. If the BST contains two or more such nodes, print any of them.
Note: We cannot use any extra space. (Assume that the implicit stack space incurred due to recursion does not count)
Assume a BST is defined as follows:
- The left subtree of a node contains only nodes with keys less than or equal to the node's key.
- The right subtree of a node contains only nodes with keys greater than or equal to the node's key.
- Both the left and right subtrees must also be binary search trees.
Examples:
Input : Given BST is
6
/ \
5 7
/ \ / \
4 5 7 7
Output : 7
Input : Given BST is
10
/ \
5 12
/ \ / \
5 6 12 16
Output : 5 or 12
We can print any of the two value 5 or 12.
Approach:
To find the node, we need to find the Inorder Traversal of the BST because its Inorder Traversal will be in sorted order.
So, the idea is to do recursive Inorder traversal and keeping the track of the previous node. If the current node value is equal to the previous value we can increase the current count and if the current count becomes greater than the maximum count, replace the element.
Below is the implementation of the above approach:
C++
/* C++ program to find the median of BST in O(n)
time and O(1) space*/
#include <iostream>
using namespace std;
/* A binary search tree Node has data, pointer
to left child and a pointer to right child */
struct Node {
int val;
struct Node *left, *right;
};
struct Node* newNode(int data)
{
struct Node* temp = new Node;
temp->val = data;
temp->left = temp->right = NULL;
return temp;
}
// cur for storing the current count of the value
// and mx for the maximum count of the element which is denoted by node
int cur = 1, mx = 0;
int node;
struct Node* previous = NULL;
// Find the inorder traversal of the BST
void inorder(struct Node* root)
{
// If root is NULL then return
if (root == NULL) {
return;
}
inorder(root->left);
if (previous != NULL) {
// If the previous value is equal to the current value
// then increase the count
if (root->val == previous->val) {
cur++;
}
// Else initialize the count by 1
else {
cur = 1;
}
}
// If current count is greater than the max count
// then update the mx value
if (cur > mx) {
mx = cur;
node = root->val;
}
// Make the current Node as previous
previous = root;
inorder(root->right);
}
// Utility function
int findnode(struct Node* root)
{
inorder(root);
return node;
}
int main()
{
/* Let us create following BST
6
/ \
5 7
/ \ / \
4 5 7 7
*/
struct Node* root = newNode(6);
root->left = newNode(5);
root->right = newNode(7);
root->left->left = newNode(4);
root->left->right = newNode(5);
root->right->left = newNode(7);
root->right->right = newNode(7);
cout << "Node of BST is " << findnode(root) << '\n';
return 0;
}
/* Java program to find the median of BST
in O(n) time and O(1) space*/
class GFG
{
/* A binary search tree Node has data, pointer
to left child and a pointer to right child */
static class Node
{
int val;
Node left, right;
};
static Node newNode(int data)
{
Node temp = new Node();
temp.val = data;
temp.left = temp.right = null;
return temp;
}
// cur for storing the current count
// of the value and mx for the maximum count
// of the element which is denoted by node
static int cur = 1, mx = 0;
static int node;
static Node previous = null;
// Find the inorder traversal of the BST
static void inorder(Node root)
{
// If root is null then return
if (root == null)
{
return;
}
inorder(root.left);
if (previous != null)
{
// If the previous value is equal to
// the current value then increase the count
if (root.val == previous.val)
{
cur++;
}
// Else initialize the count by 1
else
{
cur = 1;
}
}
// If current count is greater than the
// max count then update the mx value
if (cur > mx)
{
mx = cur;
node = root.val;
}
// Make the current Node as previous
previous = root;
inorder(root.right);
}
// Utility function
static int findnode(Node root)
{
inorder(root);
return node;
}
// Java Code
public static void main(String args[])
{
/* Let us create following BST
6
/ \
5 7
/ \ / \
4 5 7 7
*/
Node root = newNode(6);
root.left = newNode(5);
root.right = newNode(7);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(7);
root.right.right = newNode(7);
System.out.println("Node of BST is " +
findnode(root));
}
}
// This code is contributed by Arnab Kundu
# Python program to find the median of BST
# in O(n) time and O(1) space
# A binary search tree Node has data, pointer
# to left child and a pointer to right child
class Node:
def __init__(self):
self.val = 0
self.left = None
self.right = None
def newNode(data: int) -> Node:
temp = Node()
temp.val = data
temp.left = temp.right = None
return temp
# cur for storing the current count
# of the value and mx for the maximum count
# of the element which is denoted by node
cur = 1
mx = 0
node = 0
previous = Node()
# Find the inorder traversal of the BST
def inorder(root: Node):
global cur, mx, node, previous
# If root is null then return
if root is None:
return
inorder(root.left)
if previous is not None:
# If the previous value is equal to
# the current value then increase the count
if root.val == previous.val:
cur += 1
# Else initialize the count by 1
else:
cur = 1
# If current count is greater than the
# max count then update the mx value
if cur > mx:
mx = cur
node = root.val
# Make the current Node as previous
previous = root
inorder(root.right)
# Utility function
def findNode(root: Node) -> int:
global node
inorder(root)
return node
# Driver Code
if __name__ == "__main__":
# Let us create following BST
# 6
# / \
# 5 7
# / \ / \
# 4 5 7 7
root = newNode(6)
root.left = newNode(5)
root.right = newNode(7)
root.left.left = newNode(4)
root.left.right = newNode(5)
root.right.left = newNode(7)
root.right.right = newNode(7)
print("Node of BST is", findNode(root))
# This code is contributed by
# sanjeev2552
/* C# program to find the median of BST
in O(n) time and O(1) space*/
using System;
class GFG
{
/* A binary search tree Node has data, pointer
to left child and a pointer to right child */
public class Node
{
public int val;
public Node left, right;
};
static Node newNode(int data)
{
Node temp = new Node();
temp.val = data;
temp.left = temp.right = null;
return temp;
}
// cur for storing the current count
// of the value and mx for the maximum count
// of the element which is denoted by node
static int cur = 1, mx = 0;
static int node;
static Node previous = null;
// Find the inorder traversal of the BST
static void inorder(Node root)
{
// If root is null then return
if (root == null)
{
return;
}
inorder(root.left);
if (previous != null)
{
// If the previous value is equal to
// the current value then increase the count
if (root.val == previous.val)
{
cur++;
}
// Else initialize the count by 1
else
{
cur = 1;
}
}
// If current count is greater than the
// max count then update the mx value
if (cur > mx)
{
mx = cur;
node = root.val;
}
// Make the current Node as previous
previous = root;
inorder(root.right);
}
// Utility function
static int findnode(Node root)
{
inorder(root);
return node;
}
// Driver Code
public static void Main(String []args)
{
/* Let us create following BST
6
/ \
5 7
/ \ / \
4 5 7 7
*/
Node root = newNode(6);
root.left = newNode(5);
root.right = newNode(7);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(7);
root.right.right = newNode(7);
Console.WriteLine("Node of BST is " +
findnode(root));
}
}
// This code is contributed by PrinciRaj1992
<script>
/* Javascript program to find the median of BST
in O(n) time and O(1) space*/
/* A binary search tree Node has data, pointer
to left child and a pointer to right child */
class Node
{
constructor()
{
this.val = 0;
this.left = null;
this.right = null;
}
};
function newNode(data)
{
var temp = new Node();
temp.val = data;
temp.left = temp.right = null;
return temp;
}
// cur for storing the current count
// of the value and mx for the maximum count
// of the element which is denoted by node
var cur = 1, mx = 0;
var node;
var previous = null;
// Find the inorder traversal of the BST
function inorder(root)
{
// If root is null then return
if (root == null)
{
return;
}
inorder(root.left);
if (previous != null)
{
// If the previous value is equal to
// the current value then increase the count
if (root.val == previous.val)
{
cur++;
}
// Else initialize the count by 1
else
{
cur = 1;
}
}
// If current count is greater than the
// max count then update the mx value
if (cur > mx)
{
mx = cur;
node = root.val;
}
// Make the current Node as previous
previous = root;
inorder(root.right);
}
// Utility function
function findnode(root)
{
inorder(root);
return node;
}
// Driver Code
/* Let us create following BST
6
/ \
5 7
/ \ / \
4 5 7 7
*/
var root = newNode(6);
root.left = newNode(5);
root.right = newNode(7);
root.left.left = newNode(4);
root.left.right = newNode(5);
root.right.left = newNode(7);
root.right.right = newNode(7);
document.write("Node of BST is " +
findnode(root));
// This code is contributed by noob2000.
</script>
Time complexity : O(N)
Auxiliary Space: O(N).
Similar Reads
Count of duplicate Subtrees in an N-ary Tree Given the root of an n-ary tree, the task is to find the number of subtrees that have duplicates in the n-ary tree. Two trees are duplicates if they have the same structure with the same node values. Examples: Input: 1 N 2 2 3 N 4 N 4 4 3 N N N N NOutput: 2Explanation: [4], [3] are duplicate subtree
6 min read
Find all duplicate levels of given Binary Tree A binary tree is a tree data structure in which each node has at most two child nodes, referred to as the left and right children. In this question, the task is to find all the duplicate levels of a given binary tree. This problem can be used to identify and resolve any duplicate nodes or values in
13 min read
Count the number of Nodes in a Binary Tree in Constant Space Given a binary tree having N nodes, count the number of nodes using constant O(1) space. This can be done by simple traversals like- Preorder, InOrder, PostOrder, and LevelOrder but these traversals require an extra space which is equal to the height of the tree. Examples: Input: Output: 5Explanatio
10 min read
How to handle duplicates in Binary Search Tree? In a Binary Search Tree (BST), all keys in the left subtree of a key must be smaller and all keys in the right subtree must be greater. So a Binary Search Tree by definition has distinct keys. How can duplicates be allowed where every insertion inserts one more key with a value and every deletion de
15+ min read
Count Non-Leaf nodes in a Binary Tree Given a Binary tree, count the total number of non-leaf nodes in the tree Examples: Input : Output :2 Explanation In the above tree only two nodes 1 and 2 are non-leaf nodesRecommended PracticeCount Non-Leaf Nodes in TreeTry It! We recursively traverse the given tree. While traversing, we count non-
10 min read
Count paths in a Binary Tree consisting of nodes in non-decreasing order Given a Binary Tree consisting of N nodes, the task is to find the number of paths from the root to any node X, such that all the node values in that path are at most X. Examples: Input: Below is the given Tree: Output: 4Explanation: The paths from the root to any node X that have value at most valu
15 min read