# Count nodes having smallest value in the path from root to itself in a Binary Tree

• Difficulty Level : Medium
• Last Updated : 22 Jun, 2021

Given a Binary Tree, the task is to count the number of nodes in the given Binary Tree such that the path from the root to that node contains node with value greater than or equal to that node.

Examples:

```Input:
6
/   \
7     4
/ \   / \
3   7 1   2

Output: 5
Explanation:
Root node 6 is considered as its the only node
in the path from root to itself.
Node 4 has the minimum value in it's path 6->4.
Node 1 has the minimum value in it's path 6->4->1.
Node 2 has the minimum value in it's path 6->4->2.
Node 3 has the minimum value in it's path 6->7->3.

Input:
8
/   \
6     5
/ \   / \
6   7 3   9

Output: 5
Explanation:
Root node 8 is considered as its the only node
in the path from root to itself.
Node 6 has the minimum value in it's path 8->6.
Node 6 has the minimum value in it's path 8->6->6.
Node 5 has the minimum value in it's path 8->5.
Node 3 has the minimum value in it's path 8->5->3.```

Approach: The idea is to do Preorder traversal on the given Binary Tree. Follow the steps below to solve the problem:

1. Create a function to calculate the number of nodes that satisfy the given conditions.
2. If the current node is NULL then return to the previous node.
3. Use a variable minNodeVal to store the minimum node value along the path from the root to the current node.
4. If the value of the current node is less than or equal to minNodeVal then increase the final count by 1 and update the value of minNodeVal.
5. Call the function for the left and right child of the current node and repeat this process for every node to get the total count of the required nodes.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Structure of a tree node` `struct` `Node {` `    ``int` `key;` `    ``Node *left, *right;` `};`   `// Function to create new tree node` `Node* newNode(``int` `key)` `{` `    ``Node* temp = ``new` `Node;` `    ``temp->key = key;` `    ``temp->left = temp->right = NULL;` `    ``return` `temp;` `}`   `// Function to find the total` `// number of required nodes` `void` `countReqNodes(Node* root,` `                   ``int` `minNodeVal, ``int``& ans)` `{` `    ``// If current node is null then` `    ``// return to the parent node` `    ``if` `(root == NULL)` `        ``return``;`   `    ``// Check if current node value is` `    ``// less than or equal to minNodeVal` `    ``if` `(root->key <= minNodeVal) {`   `        ``// Update the value of minNodeVal` `        ``minNodeVal = root->key;`   `        ``// Update the count` `        ``ans++;` `    ``}`   `    ``// Go to the left subtree` `    ``countReqNodes(root->left,` `                  ``minNodeVal, ans);`   `    ``// Go to the right subtree` `    ``countReqNodes(root->right,` `                  ``minNodeVal, ans);` `}`   `// Driver Code` `int` `main()` `{` `    ``/* Binary Tree creation` `               ``8` `             ``/   \` `            ``/     \` `           ``6       5` `          ``/ \     /  \` `         ``/   \   /    \` `        ``6     7 3      9` `    ``*/`   `    ``Node* root = newNode(8);` `    ``root->left = newNode(6);` `    ``root->right = newNode(5);` `    ``root->left->left = newNode(6);` `    ``root->left->right = newNode(7);` `    ``root->right->left = newNode(3);` `    ``root->right->right = newNode(9);`   `    ``int` `ans = 0, minNodeVal = INT_MAX;`   `    ``// Function Call` `    ``countReqNodes(root, minNodeVal, ans);`   `    ``// Print the result` `    ``cout << ans;`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Structure of a tree node` `static` `class` `Node ` `{` `    ``int` `key;` `    ``Node left, right;` `};`   `// Function to create new tree node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `}` `static` `int` `ans;`   `// Function to find the total` `// number of required nodes` `static` `void` `countReqNodes(Node root,` `                          ``int` `minNodeVal)` `{` `    `  `    ``// If current node is null then` `    ``// return to the parent node` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Check if current node value is` `    ``// less than or equal to minNodeVal` `    ``if` `(root.key <= minNodeVal) ` `    ``{` `        `  `        ``// Update the value of minNodeVal` `        ``minNodeVal = root.key;`   `        ``// Update the count` `        ``ans++;` `    ``}`   `    ``// Go to the left subtree` `    ``countReqNodes(root.left,` `                  ``minNodeVal);`   `    ``// Go to the right subtree` `    ``countReqNodes(root.right,` `                  ``minNodeVal);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    `  `    ``/* Binary Tree creation` `               ``8` `             ``/   \` `            ``/     \` `           ``6       5` `          ``/ \     /  \` `         ``/   \   /    \` `        ``6     7 3      9` `    ``*/`   `    ``Node root = newNode(``8``);` `    ``root.left = newNode(``6``);` `    ``root.right = newNode(``5``);` `    ``root.left.left = newNode(``6``);` `    ``root.left.right = newNode(``7``);` `    ``root.right.left = newNode(``3``);` `    ``root.right.right = newNode(``9``);`   `    ``int`  `minNodeVal = Integer.MAX_VALUE;` `    ``ans = ``0``;` `    `  `    ``// Function Call` `    ``countReqNodes(root, minNodeVal);` `    `  `    ``// Print the result` `    ``System.out.print(ans);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program for the above approach` `import` `sys`   `ans ``=` `0`   `# Class of a tree node` `class` `Node:` `    `  `    ``def` `__init__(``self``, key):` `        `  `        ``self``.key ``=` `key` `        ``self``.left ``=` `None` `        ``self``.right ``=` `None`   `# Function to find the total` `# number of required nodes` `def` `countReqNodes(root, minNodeVal):` `    `  `    ``global` `ans`   `    ``# If current node is null then` `    ``# return to the parent node` `    ``if` `root ``=``=` `None``:` `        ``return` `    `  `    ``# Check if current node value is` `    ``# less than or equal to minNodeVal    ` `    ``if` `root.key <``=` `minNodeVal:` `        `  `        ``# Update the value of minNodeVal` `        ``minNodeVal ``=` `root.key`   `        ``# Update the count` `        ``ans ``+``=` `1` `        `  `    ``# Go to the left subtree    ` `    ``countReqNodes(root.left, minNodeVal)`   `    ``# Go to the right subtree` `    ``countReqNodes(root.right, minNodeVal)`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `     ``# Binary Tree creation` `     ``#           8` `     ``#         /   \` `     ``#        /     \` `     ``#       6       5` `     ``#      / \     /  \` `     ``#     /   \   /    \` `     ``#    6     7 3      9` `     ``#`   `    ``root ``=` `Node(``8``)`   `    ``root.left ``=` `Node(``6``)` `    ``root.right ``=` `Node(``5``)` `    ``root.left.left ``=` `Node(``6``)` `    ``root.left.right ``=` `Node(``7``)` `    ``root.right.left ``=` `Node(``3``)` `    ``root.right.right ``=` `Node(``9``)`   `    ``minNodeVal ``=` `sys.maxsize` `    `  `    ``# Function Call` `    ``countReqNodes(root, minNodeVal)` `    `  `    ``# Print the result` `    ``print``(ans)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Structure of a tree node` `public` `class` `Node ` `{` `    ``public` `int` `key;` `    ``public` `Node left, right;` `};`   `// Function to create new tree node` `static` `Node newNode(``int` `key)` `{` `    ``Node temp = ``new` `Node();` `    ``temp.key = key;` `    ``temp.left = temp.right = ``null``;` `    ``return` `temp;` `}`   `static` `int` `ans;`   `// Function to find the total` `// number of required nodes` `static` `void` `countReqNodes(Node root,` `                          ``int` `minNodeVal)` `{` `    `  `    ``// If current node is null then` `    ``// return to the parent node` `    ``if` `(root == ``null``)` `        ``return``;`   `    ``// Check if current node value is` `    ``// less than or equal to minNodeVal` `    ``if` `(root.key <= minNodeVal) ` `    ``{` `        `  `        ``// Update the value of minNodeVal` `        ``minNodeVal = root.key;`   `        ``// Update the count` `        ``ans++;` `    ``}`   `    ``// Go to the left subtree` `    ``countReqNodes(root.left,` `                  ``minNodeVal);`   `    ``// Go to the right subtree` `    ``countReqNodes(root.right,` `                  ``minNodeVal);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``/* Binary Tree creation` `               ``8` `             ``/   \` `            ``/     \` `           ``6       5` `          ``/ \     /  \` `         ``/   \   /    \` `        ``6     7 3      9` `    ``*/`   `    ``Node root = newNode(8);` `    ``root.left = newNode(6);` `    ``root.right = newNode(5);` `    ``root.left.left = newNode(6);` `    ``root.left.right = newNode(7);` `    ``root.right.left = newNode(3);` `    ``root.right.right = newNode(9);`   `    ``int`  `minNodeVal = ``int``.MaxValue;` `    ``ans = 0;` `    `  `    ``// Function Call` `    ``countReqNodes(root, minNodeVal);` `    `  `    ``// Print the result` `    ``Console.Write(ans);` `}` `}`   `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`5`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Related Articles