Special two digit numbers in a Binary Search Tree

Last Updated : 01 Dec, 2022

Given a Binary Search Trees, the task is to count the number of nodes which are having special two-digit numbers.
Prerequisite : Special Two Digit Number | Binary Search Tree

Examples :

Input : 15 7 987 21
Output : 0

Input : 19 99 57 1 22
Output : 2

Algorithm: Iterate through each node of tree recursively with a variable count, and check each node’s data for a special two-digit number. If it is then increment the variable count. In the end, return count.

Implementation:

C++

// C++ program to count number of nodes in
// BST containing two digit special number
#include <bits/stdc++.h>
using namespace std;
 
// A Tree node
struct Node
{
    struct Node *left;
    int info;
    struct Node *right;
};
 
// Function to create a new node
void insert(struct Node **rt, int key)
{
    if(*rt == NULL)
    {
        (*rt) = new Node();
        (*rt) -> left = NULL;
        (*rt) -> right = NULL;
        (*rt) -> info = key;
    }
    else if(key < ((*rt) -> info))
        insert(&((*rt) -> left), key);
    else
        insert(&(*rt) -> right, key);
}
 
// Function to find if number
// is special or not
int check(int num)
{
    int sum = 0, i = num, sum_of_digits, prod_of_digits ;
     
    // Check if number is two digit or not
    if(num < 10 || num > 99)
        return 0;
    else
    {
        sum_of_digits = (i % 10) + (i / 10);
        prod_of_digits = (i % 10) * (i / 10);
        sum = sum_of_digits + prod_of_digits;
    }
     
    if(sum == num)
        return 1;
    else
        return 0;
}
 
// Function to count number of special two digit number
void countSpecialDigit(struct Node *rt, int *c)
{
    int x;
    if(rt == NULL)
        return;
    else
    {
        x = check(rt -> info);
        if(x == 1)
            *c = *c + 1;
        countSpecialDigit(rt -> left, c);
        countSpecialDigit(rt -> right, c);
    }
}
 
// Driver program to test
int main()
{
    struct Node *root = NULL;
     
    // Initialize result
    int count = 0;
     
    // Function call to insert() to insert nodes
    insert(&root, 50);
    insert(&root, 29);
    insert(&root, 59);
    insert(&root, 19);
    insert(&root, 53);
    insert(&root, 556);
    insert(&root, 56);
    insert(&root, 94);
    insert(&root, 13);
 
    // Function call, to check each node for 
    // special two digit number
    countSpecialDigit(root, &count);
    cout<< count;
     
    return 0;
}
 
// This code is contributed by itsok.

C

// C program to count number of nodes in
// BST containing two digit special number
#include <stdio.h>
#include <stdlib.h>
 
// A Tree node
struct Node
{
    struct Node *left;
    int info;
    struct Node *right;
};
 
// Function to create a new node
void insert(struct Node **rt, int key)
{
    if(*rt == NULL)
    {
        (*rt) = (struct Node *)malloc(sizeof(struct Node));
        (*rt) -> left = NULL;
        (*rt) -> right = NULL;
        (*rt) -> info = key;
    }
    else if(key < ((*rt) -> info))
        insert(&((*rt) -> left), key);
    else
        insert(&(*rt) -> right, key);
}
 
// Function to find if number
// is special or not
int check(int num)
{
    int sum = 0, i = num, sum_of_digits, prod_of_digits ;
     
    // Check if number is two digit or not
    if(num < 10 || num > 99)
        return 0;
    else
    {
        sum_of_digits = (i % 10) + (i / 10);
        prod_of_digits = (i % 10) * (i / 10);
        sum = sum_of_digits + prod_of_digits;
    }
     
    if(sum == num)
        return 1;
    else
        return 0;
}
 
// Function to count number of special two digit number
void countSpecialDigit(struct Node *rt, int *c)
{
    int x;
    if(rt == NULL)
        return;
    else
    {
        x = check(rt -> info);
        if(x == 1)
            *c = *c + 1;
        countSpecialDigit(rt -> left, c);
        countSpecialDigit(rt -> right, c);
    }
}
 
// Driver program to test
int main()
{
    struct Node *root = NULL;
     
    // Initialize result
    int count = 0;
     
    // Function call to insert() to insert nodes
    insert(&root, 50);
    insert(&root, 29);
    insert(&root, 59);
    insert(&root, 19);
    insert(&root, 53);
    insert(&root, 556);
    insert(&root, 56);
    insert(&root, 94);
    insert(&root, 13);
 
    // Function call, to check each node for 
    // special two digit number
    countSpecialDigit(root, &count);
    printf("%d", count);
     
    return 0;
}

Java

// Java program to count number of nodes in
// BST containing two digit special number
 
// A binary tree node
class Node
{
    int info;
    Node left, right;
 
    Node(int d)
    {
        info = d;
        left = right = null;
    }
}
 
class BinaryTree{
 
static Node head;
static int count;
 
// Function to create a new node 
Node insert(Node node, int info)
{
     
    // If the tree is empty, return a new,
    // single node
    if (node == null)
    {
        return (new Node(info));
    }
    else
    {
         
        // Otherwise, recur down the tree 
        if (info <= node.info)
        {
            node.left = insert(node.left, info);
        }
        else
        {
            node.right = insert(node.right, info);
        }
 
        // return the (unchanged) node pointer 
        return node;
    }
}
 
// Function to find if number
// is special or not
static int check(int num)
{
    int sum = 0, i = num, 
        sum_of_digits, 
        prod_of_digits;
 
    // Check if number is two digit or not
    if (num < 10 || num > 99)
        return 0;
    else
    {
        sum_of_digits = (i % 10) + (i / 10);
        prod_of_digits = (i % 10) * (i / 10);
        sum = sum_of_digits + prod_of_digits;
    }
 
    if (sum == num)
        return 1;
    else
        return 0;
}
 
// Function to count number of special
// two digit number
static void countSpecialDigit(Node rt)
{
    int x;
    if (rt == null)
        return;
    else
    {
        x = check(rt.info);
        if (x == 1)
            count = count + 1;
             
        countSpecialDigit(rt.left);
        countSpecialDigit(rt.right);
    }
}
 
// Driver code
public static void main(String[] args)
{
    BinaryTree tree = new BinaryTree();
    Node root = null;
     
    root = tree.insert(root, 50);
    tree.insert(root, 29);
    tree.insert(root, 59);
    tree.insert(root, 19);
    tree.insert(root, 53);
    tree.insert(root, 556);
    tree.insert(root, 56);
    tree.insert(root, 94);
    tree.insert(root, 13);
     
    // Function call
    countSpecialDigit(root);
    System.out.println(count);
}
}
 
// This code is contributed by tushar_bansal

Python3

# Python3 program to count number of nodes in
# BST containing two digit special number
 
# A Tree node
class Node:
     
    def __init__(self, x):
         
        self.data = x
        self.left = None
        self.right = None
 
# Function to create a new node
def insert(node, data):
     
    global succ
     
    # If the tree is empty, return
    # a new node 
    root = node
 
    if (node == None):
        return Node(data)
 
    # If key is smaller than root's key,
    # go to left subtree and set successor
    # as current node
    if (data < node.data):
        root.left = insert(node.left, data)
 
    # Go to right subtree
    elif (data > node.data):
        root.right = insert(node.right, data)
         
    return root
 
# Function to find if number
# is special or not
def check(num):
     
    sum = 0
    i = num
    #sum_of_digits, prod_of_digits
 
    # Check if number is two digit or not
    if (num < 10 or num > 99):
        return 0
    else:
        sum_of_digits = (i % 10) + (i // 10)
        prod_of_digits = (i % 10) * (i // 10)
        sum = sum_of_digits + prod_of_digits
 
    if (sum == num):
        return 1
    else:
        return 0
 
# Function to count number of special
# two digit number
def countSpecialDigit(rt):
     
    global c
     
    if (rt == None):
        return
    else:
        x = check(rt.data)
        if (x == 1):
            c += 1
             
        countSpecialDigit(rt.left)
        countSpecialDigit(rt.right)
 
# Driver code
if __name__ == '__main__':
     
    root = None
 
    # Initialize result
    c = 0
 
    # Function call to insert() to
    # insert nodes
    root = insert(root, 50)
    root = insert(root, 29)
    root = insert(root, 59)
    root = insert(root, 19)
    root = insert(root, 53)
    root = insert(root, 556)
    root = insert(root, 56)
    root = insert(root, 94)
    root = insert(root, 13)
 
    # Function call, to check each node
    # for special two digit number
    countSpecialDigit(root)
     
    print(c)
 
# This code is contributed by mohit kumar 29

C#

// C# program to count number of nodes in
// BST containing two digit special number
 
// A binary tree node
using System;
public class Node 
{ 
  public int info; 
  public Node left, right;  
  public Node(int d) 
  { 
    info = d; 
    left = right = null; 
  } 
} 
public class BinaryTree
{
  public static Node head;
  public static int count;
 
  // Function to create a new node 
  public Node insert(Node node, int info)
  {
 
    // If the tree is empty, return a new,
    // single node
    if(node == null)
    {
      return (new Node(info));
    }
    else
    {
 
      // Otherwise, recur down the tree 
      if(info <= node.info)
      {
        node.left = insert(node.left, info);
      }
      else
      {
        node.right = insert(node.right, info);
      }
    }
 
    // return the (unchanged) node pointer 
    return node;
  }
 
  // Function to find if number
  // is special or not
  static int check(int num)
  {
    int sum = 0, i = num, sum_of_digits, prod_of_digits;
 
    // Check if number is two digit or not
    if(num < 10 || num > 99)
    {
      return 0;
    }
    else
    {
      sum_of_digits = (i % 10) + (i / 10);
      prod_of_digits = (i % 10) * (i / 10);
      sum = sum_of_digits + prod_of_digits;
    }
    if(sum == num)
    {
      return 1;
    }
    else
    {
      return 0;
    }
  }
 
  // Function to count number of special
  // two digit number
  static void countSpecialDigit(Node rt)
  {
    int x;
    if(rt == null)
    {
      return;
    }
    else
    {
      x = check(rt.info);
      if(x == 1)
      {
        count = count + 1;
 
      }
      countSpecialDigit(rt.left);
      countSpecialDigit(rt.right);
    }
  }
 
  // Driver code
  static public void Main ()
  {
    BinaryTree tree = new BinaryTree();
    Node root = null;
    root = tree.insert(root, 50);
    tree.insert(root, 29);
    tree.insert(root, 59);
    tree.insert(root, 19);
    tree.insert(root, 53);
    tree.insert(root, 556);
    tree.insert(root, 56);
    tree.insert(root, 94);
    tree.insert(root, 13);
 
    // Function call
    countSpecialDigit(root);
    Console.WriteLine(count);
  }
}
 
// This code is contributed by avanitrachhadiya2155

Javascript

<script>
// Javascript program to count number of nodes in
// BST containing two digit special number
 
// A binary tree node
class Node
{
    constructor(d)
    {
        this.info = d;
        this.left = this.right = null;
    }
}
 
let head;
let count=0;
 
// Function to create a new node
function insert(node,info)
{
    // If the tree is empty, return a new,
    // single node
    if (node == null)
    {
        return (new Node(info));
    }
    else
    {
          
        // Otherwise, recur down the tree
        if (info <= node.info)
        {
            node.left = insert(node.left, info);
        }
        else
        {
            node.right = insert(node.right, info);
        }
  
        // return the (unchanged) node pointer
        return node;
    }
}
 
// Function to find if number
// is special or not
function check(num)
{
    let sum = 0, i = num,
        sum_of_digits,
        prod_of_digits;
  
    // Check if number is two digit or not
    if (num < 10 || num > 99)
        return 0;
    else
    {
        sum_of_digits = (i % 10) + Math.floor(i / 10);
        prod_of_digits = (i % 10) * Math.floor(i / 10);
        sum = sum_of_digits + prod_of_digits;
    }
  
    if (sum == num)
        return 1;
    else
        return 0;
}
 
// Function to count number of special
// two digit number
function countSpecialDigit(rt)
{
    let x;
    if (rt == null)
        return;
    else
    {
        x = check(rt.info);
        if (x == 1)
            count = count + 1;
              
        countSpecialDigit(rt.left);
        countSpecialDigit(rt.right);
    }
}
 
// Driver code
let root = null;
 
root = insert(root, 50);
root=insert(root, 29);
root=insert(root, 59);
root=insert(root, 19);
root=insert(root, 53);
root=insert(root, 556);
root=insert(root, 56);
root=insert(root, 94);
root=insert(root, 13);
 
// Function call
countSpecialDigit(root);
document.write(count);
 
 
 
// This code is contributed by unknown2108
</script>

Output

Time Complexity: O(N), Where N is the number of nodes in Tree.
Auxiliary Space: O(h), Here h is the height of the tree and this extra space is used due to the recursion call stack.

Suggest improvement

Minimum Possible value of |ai + aj - k| for given array and k.

Merge Two Balanced Binary Search Trees

Share your thoughts in the comments

Easy problems on Binary Search Tree

Intermediate problems on Binary Search Tree

Hard problems on Binary Search Tree