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 0Input: 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++ 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 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 |
# 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# 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 |
<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> |
2
Time Complexity: O(N)
Auxiliary Space: O(1)