Related Articles

# Count of nodes that are greater than Ancestors

• Last Updated : 10 Jun, 2021

Given the root of a tree, the task is to find the count of nodes which are greater than all of its ancestors.
Examples:

```Input:
4
/ \
5   2
/ \
3   6
Output: 3
The nodes are 4, 5 and 6.

Input:
10
/  \
8    6
\    \
3    5
/
1
Output: 1```

Approach: The problem can be solved using dfs. In every function call, pass a variable maxx which stores the maximum among all the nodes traversed so far, and every node whose value is greater than maxx is the node that satisfies the given condition. Hence, increment the count.
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Structure for the node of the tree``struct` `Tree {``    ``int` `val;``    ``Tree* left;``    ``Tree* right;``    ``Tree(``int` `_val)``    ``{``        ``val = _val;``        ``left = NULL;``        ``right = NULL;``    ``}``};` `// Dfs Function``void` `dfs(Tree* node, ``int` `maxx, ``int``& count)``{``    ``// Base case``    ``if` `(node == NULL) {``        ``return``;``    ``}``    ``else` `{` `        ``// Increment the count if the current``        ``// node's value is greater than the``        ``// maximum value in it's ancestors``        ``if` `(node->val > maxx)``            ``count++;` `        ``// Left traversal``        ``dfs(node->left, max(maxx, node->val), count);` `        ``// Right traversal``        ``dfs(node->right, max(maxx, node->val), count);``    ``}``}` `// Driver code``int` `main()``{` `    ``Tree* root = ``new` `Tree(4);``    ``root->left = ``new` `Tree(5);``    ``root->right = ``new` `Tree(2);``    ``root->right->left = ``new` `Tree(3);``    ``root->right->right = ``new` `Tree(6);` `    ``// To store the required count``    ``int` `count = 0;` `    ``dfs(root, INT_MIN, count);` `    ``cout << count;` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``class` `GFG``{` `static` `int` `count;` `// Structure for the node of the tree``static` `class` `Tree``{``    ``int` `val;``    ``Tree left;``    ``Tree right;``    ``Tree(``int` `_val)``    ``{``        ``val = _val;``        ``left = ``null``;``        ``right = ``null``;``    ``}``};` `// Dfs Function``static` `void` `dfs(Tree node, ``int` `maxx)``{``    ``// Base case``    ``if` `(node == ``null``)``    ``{``        ``return``;``    ``}``    ``else``    ``{` `        ``// Increment the count if the current``        ``// node's value is greater than the``        ``// maximum value in it's ancestors``        ``if` `(node.val > maxx)``            ``count++;` `        ``// Left traversal``        ``dfs(node.left, Math.max(maxx, node.val));` `        ``// Right traversal``        ``dfs(node.right, Math.max(maxx, node.val));``    ``}``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``Tree root = ``new` `Tree(``4``);``    ``root.left = ``new` `Tree(``5``);``    ``root.right = ``new` `Tree(``2``);``    ``root.right.left = ``new` `Tree(``3``);``    ``root.right.right = ``new` `Tree(``6``);` `    ``// To store the required count``    ``count = ``0``;` `    ``dfs(root, Integer.MIN_VALUE);` `    ``System.out.print(count);``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program for the``# above approach``from` `collections ``import` `deque` `# A Tree node``class` `Tree:``  ` `    ``def` `__init__(``self``, x):``      ` `        ``self``.val ``=` `x``        ``self``.left ``=` `None``        ``self``.right ``=` `None` `count ``=` `0` `# Dfs Function``def` `dfs(node, maxx):``  ` `    ``global` `count``    ` `    ``# Base case``    ``if` `(node ``=``=` `None``):``        ``return``    ``else``:` `        ``# Increment the count if``        ``# the current node's value``        ``# is greater than the maximum``        ``# value in it's ancestors``        ``if` `(node.val > maxx):``            ``count ``+``=` `1` `        ``# Left traversal``        ``dfs(node.left,``            ``max``(maxx,``                ``node.val))` `        ``# Right traversal``        ``dfs(node.right,``            ``max``(maxx,``                ``node.val))``        ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:` `    ``root ``=` `Tree(``4``)``    ``root.left ``=` `Tree(``5``)``    ``root.right ``=` `Tree(``2``)``    ``root.right.left ``=` `Tree(``3``)``    ``root.right.right ``=` `Tree(``6``)` `    ``# To store the required``    ``# count``    ``count ``=` `0` `    ``dfs(root,``        ``-``10` `*``*` `9``)``    ``print``(count)` `# This code is contributed by Mohit Kumar 29`

## C#

 `// C# implementation of the approach``using` `System;` `class` `GFG``{``static` `int` `count;` `// Structure for the node of the tree``public` `class` `Tree``{``    ``public` `int` `val;``    ``public` `Tree left;``    ``public` `Tree right;``    ``public` `Tree(``int` `_val)``    ``{``        ``val = _val;``        ``left = ``null``;``        ``right = ``null``;``    ``}``};` `// Dfs Function``static` `void` `dfs(Tree node, ``int` `maxx)``{``    ``// Base case``    ``if` `(node == ``null``)``    ``{``        ``return``;``    ``}``    ``else``    ``{` `        ``// Increment the count if the current``        ``// node's value is greater than the``        ``// maximum value in it's ancestors``        ``if` `(node.val > maxx)``            ``count++;` `        ``// Left traversal``        ``dfs(node.left, Math.Max(maxx, node.val));` `        ``// Right traversal``        ``dfs(node.right, Math.Max(maxx, node.val));``    ``}``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``Tree root = ``new` `Tree(4);``    ``root.left = ``new` `Tree(5);``    ``root.right = ``new` `Tree(2);``    ``root.right.left = ``new` `Tree(3);``    ``root.right.right = ``new` `Tree(6);` `    ``// To store the required count``    ``count = 0;` `    ``dfs(root, ``int``.MinValue);` `    ``Console.Write(count);``}``}` `// This code is contributed by Rajput-Ji`

## Javascript

 ``
Output:
`3`

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up