Related Articles

Related Articles

Count nodes having smallest value in the path from root to itself in a Binary Tree
  • Difficulty Level : Medium
  • Last Updated : 29 Oct, 2020

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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output: 

5
















 

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

 

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :