# Find maximum count of duplicate nodes in a Binary Search Tree

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.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 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 currrent 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

 /* 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 currrent 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

## Python3

 # 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 currrent 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#

 /* 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 currrent 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; }    // Drive 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

Output:

node of BST is 7

Time complexity :

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.