ISRO CS 2016 - Question 22

Introduction

The International Space Research Organization (ISRO) is India's national space agency, responsible for carrying out space research and exploration missions. The ISRO Computer Science 2016 exam featured a question regarding binary search trees, a data structure used in computer science for efficient data organization and retrieval.

Problem Statement

The problem statement for ISRO CS 2016 - Question 22 is as follows:

You are given a binary search tree and a sum S. Write a function to determine if there exists a pair of nodes in the tree whose sum equals S.

The function should take in the root node of the binary search tree as well as the sum S as input, and should return True or False to indicate whether or not a pair of nodes exists that sums to S.

Sample Input/Output

Sample Input

         8
       /   \
     3      10
   /  \       \
  1    6       14
      /  \    /
     4    7  13

S = 15

Sample Output

True

Solution

The solution to this problem requires a depth-first search traversal of the binary search tree. The algorithm traverses the tree while keeping track of the sum of the data values encountered in each node. If the current sum equals the input value S, then the function returns True. If the current sum is greater than S, the search on that branch is terminated. The pairs having a node with minimum value and a node with maximum value can be checked for while traversing the tree.

Here's the python implementation of the solution:

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None
 
def insert(root, data):
    if root is None:
        return Node(data)
    else:
        if data < root.data:
            root.left = insert(root.left, data)
        else:
            root.right = insert(root.right, data)
    return root
 
def findPair(root, val):
    if root is None:
        return False
    s1 = []
    s2 = []
    curr1 = root
    curr2 = root
    done1 = False
    done2 = False
    val1 = 0
    val2 = 0
    while (True):
 
        while (done1 == False):
            if (curr1 != None):
                s1.append(curr1)
                curr1 = curr1.left
            else:
                if (len(s1) > 0):
                    curr1 = s1.pop()
                    val1 = curr1.data
                    curr1 = curr1.right
                    done1 = True
                else:
                    done1 = True
 
        while (done2 == False):
            if (curr2 != None):
                s2.append(curr2)
                curr2 = curr2.right
            else:
                if (len(s2) > 0):
                    curr2 = s2.pop()
                    val2 = curr2.data
                    curr2 = curr2.left
                    done2 = True
                else:
                    done2 = True
 
        if ((val1 != val2) and (val1 + val2) == val):
            return True
 
        if ((val1 + val2) < val):
            done1 = False
 
        if ((val1 + val2) > val):
            done2 = False
 
        if (val1 >= val2):
            return False

The insert function is used to add nodes to the binary search tree, while findPair is used to find pairs of nodes that sum to S.

Conclusion

The ISRO CS 2016 - Question 22 focused on the implementation of binary search trees and depth-first search traversal. Binary search trees are used in computer science to efficiently organize data, while depth-first search traversal is used to efficiently search for data within a data structure. This implementation can be used as a template for similar problems involving binary search trees.