Open In App

Count of Nodes whose children gives same remainder when divided by K

Improve
Improve
Like Article
Like
Save
Share
Report

Given a binary tree and an integer K. The task is to count the number of nodes having children that give the same remainder when divided by K. Print “-1” if no such node exists.

Examples:

Input:    2         K = 2
             / \
           3   5
         /    / \
       7   8   6
Output: 2
Explanation: Children of 2 are 3 and 5. Both give remainder 1 with 2
Similarly for 5, both children give remainder as 0

Input: 9        K = 5
           / \
         7   8
             / \
           4   3
Output: -1
Explanation: There is no node having both children with same remainder with K.

 

Approach: This problem can be solved by simple binary tree traversal. Follow the steps below to solve the given problem.

  • Traverse the Binary tree, and for each node, check
  • If the node has a left child
  • If the node has a right child
  • If both children give the same remainder with K.
  • Count all such nodes and print their content at the end.

Below is the implementation of the above approach.

C++




// C++ implementation to print
// the nodes having a single child
#include <bits/stdc++.h>
using namespace std;
 
// Class of the Binary Tree node
struct Node {
    int data;
    Node *left, *right;
 
    Node(int x)
    {
        data = x;
        left = right = NULL;
    }
};
 
// Function to find the nodes having both
// and both of them % K are same
int countNodes(Node* root, int& K, int count)
{
    // Base case
    if (root == NULL)
        return count;
 
    // Condition to check if the
    // node is having both child
    // and both of them % K are same
    if (root->left != NULL
        && root->right != NULL
        && root->left->data % K
            == root->right->data % K) {
 
        count++;
    }
 
    // Traversing the left child
    count = countNodes(root->left, K, count);
 
    // Traversing the right child
    count = countNodes(root->right, K, count);
    return count;
}
 
// Driver code
int main()
{
   
    // Constructing the binary tree
    Node* root = new Node(2);
    root->left = new Node(3);
    root->right = new Node(5);
    root->left->left = new Node(7);
    root->right->left = new Node(8);
    root->right->right = new Node(6);
 
    int K = 2;
 
    // Function calling
    cout << countNodes(root, K, 0);
}


Java




// Java code for the above approach
 
import java.io.*;
class Node {
    int data;
    Node left, right;
 
    Node(int data)
    {
        this.data = data;
        left = null;
        right = null;
    }
};
 
class GFG {
    // Function to find the nodes having both
    // and both of them % K are same
    static int countNodes(Node root, int K, int count)
    {
        // Base case
        if (root == null)
            return count;
 
        // Condition to check if the
        // node is having both child
        // and both of them % K are same
        if (root.left != null && root.right != null
            && (root.left.data % K
                == root.right.data % K)) {
 
            count++;
        }
 
        // Traversing the left child
        count = countNodes(root.left, K, count);
 
        // Traversing the right child
        count = countNodes(root.right, K, count);
        return count;
    }
    public static void main(String[] args)
    {
        // Driver code
 
        // Constructing the binary tree
        Node root = new Node(2);
        root.left = new Node(3);
        root.right = new Node(5);
        root.left.left = new Node(7);
        root.right.left = new Node(8);
        root.right.right = new Node(6);
 
        int K = 2;
 
        // Function calling
 
        System.out.println(countNodes(root, K, 0));
    }
}
//This code is contributed by Potta Lokesh


Python3




# Python code for the above approach
class Node:
    def __init__(self, data):
        self.data = data;
        self.left = None;
        self.right = None;
 
# Function to find the Nodes having both
# and both of them % K are same
def countNodes(root, K, count):
   
    # Base case
    if (root == None):
        return count;
 
    # Condition to check if the
    # Node is having both child
    # and both of them % K are same
    if (root.left != None and root.right != None and (root.left.data % K == root.right.data % K)):
 
        count += 1;
     
    # Traversing the left child
    count = countNodes(root.left, K, count);
 
    # Traversing the right child
    count = countNodes(root.right, K, count);
    return count;
 
if __name__ == '__main__':
    # Driver code
 
    # Constructing the binary tree
    root =  Node(2);
    root.left =  Node(3);
    root.right =  Node(5);
    root.left.left =  Node(7);
    root.right.left =  Node(8);
    root.right.right =  Node(6);
 
    K = 2;
 
    # Function calling
    print(countNodes(root, K, 0));
 
# This code is contributed by umadevi9616


C#




// C# code for the above approach
using System;
using System.Collections.Generic;
 
class Node {
  public int data;
  public Node left, right;
 
  public Node(int data)
  {
    this.data = data;
    left = null;
    right = null;
  }
};
 
public class GFG
{
 
  // Function to find the nodes having both
  // and both of them % K are same
  static int countNodes(Node root, int K, int count)
  {
 
    // Base case
    if (root == null)
      return count;
 
    // Condition to check if the
    // node is having both child
    // and both of them % K are same
    if (root.left != null && root.right != null
        && (root.left.data % K
            == root.right.data % K)) {
 
      count++;
    }
 
    // Traversing the left child
    count = countNodes(root.left, K, count);
 
    // Traversing the right child
    count = countNodes(root.right, K, count);
    return count;
  }
  public static void Main(String[] args)
  {
    // Driver code
 
    // Constructing the binary tree
    Node root = new Node(2);
    root.left = new Node(3);
    root.right = new Node(5);
    root.left.left = new Node(7);
    root.right.left = new Node(8);
    root.right.right = new Node(6);
 
    int K = 2;
 
    // Function calling
 
    Console.WriteLine(countNodes(root, K, 0));
  }
}
 
// This code is contributed by 29AjayKumar


Javascript




<script>
// Javascript code for the above approach
class Node {
 
    constructor(data) {
        this.data = data;
        this.left = null;
        this.right = null;
    }
};
 
// Function to find the nodes having both
// and both of them % K are same
function countNodes(root, K, count)
{
 
    // Base case
    if (root == null)
        return count;
 
    // Condition to check if the
    // node is having both child
    // and both of them % K are same
    if (root.left != null && root.right != null
        && (root.left.data % K
            == root.right.data % K)) {
 
        count++;
    }
 
    // Traversing the left child
    count = countNodes(root.left, K, count);
 
    // Traversing the right child
    count = countNodes(root.right, K, count);
    return count;
}
 
// Driver code
 
// Constructing the binary tree
let root = new Node(2);
root.left = new Node(3);
root.right = new Node(5);
root.left.left = new Node(7);
root.right.left = new Node(8);
root.right.right = new Node(6);
 
let K = 2;
 
// Function calling
 
document.write(countNodes(root, K, 0));
 
// This code is contributed by Saurabh Jaiswal
</script>


Output

2

 
 

 

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

 



Last Updated : 02 Mar, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads