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

• Difficulty Level : Easy
• 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 ``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

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

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

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

## Javascript

 ``
Output:
`node of BST is 7`

Time complexity : Auxiliary Space: O(N).

My Personal Notes arrow_drop_up