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

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)