ISRO CS 2011 Question 51

Introduction

ISRO CS 2011 Question 51 is a programming question that tests the knowledge and skills of the programmer in implementing a binary tree data structure and its operations.

Problem Statement

The problem requires the programmer to implement a binary tree data structure and its operations. It then requires the programmer to perform a specific operation on the binary tree.

Solution

Binary Tree Implementation

To implement a binary tree data structure, we will define a class named Node. The Node class represents a single node in the binary tree, and contains the data, left, and right attributes.

class Node:
    def __init__(self, data):
        self.data = data
        self.left = None
        self.right = None

We will then define another class named BinaryTree. The BinaryTree class represents the binary tree itself, and contains the root attribute.

class BinaryTree:
    def __init__(self):
        self.root = None

Binary Tree Operations

We will implement the following operations on the binary tree:

• insert: inserts a new node into the binary tree
• search: searches for a node in the binary tree
• inorder_traversal: performs an inorder traversal of the binary tree

class BinaryTree:
    def __init__(self):
        self.root = None
    
    def insert(self, data):
        node = Node(data)
        if self.root is None:
            self.root = node
        else:
            queue = []
            queue.append(self.root)
            while len(queue) > 0:
                current = queue.pop(0)
                if current.left is None:
                    current.left = node
                    return
                elif current.right is None:
                    current.right = node
                    return
                else:
                    queue.append(current.left)
                    queue.append(current.right)
                    
    def search(self, data):
        if self.root is None:
            return False
        else:
            queue = []
            queue.append(self.root)
            while len(queue) > 0:
                current = queue.pop(0)
                if current.data == data:
                    return True
                if current.left:
                    queue.append(current.left)
                if current.right:
                    queue.append(current.right)
            return False
            
    def inorder_traversal(self, node):
        if node is None:
            return
        self.inorder_traversal(node.left)
        print(node.data, end=' ')
        self.inorder_traversal(node.right)

Specific Operation

Now that we have implemented the binary tree data structure and its operations, we can perform the specific operation required by the problem statement. The problem requires us to find the sum of all the elements at odd level in the binary tree.

def odd_level_sum(tree):
    sum = 0
    if tree.root is None:
        return sum
    else:
        queue = []
        queue.append(tree.root)
        level = 1
        while len(queue) > 0:
            current_level = []
            for i in range(len(queue)):
                current = queue.pop(0)
                current_level.append(current)
                if current.left:
                    queue.append(current.left)
                if current.right:
                    queue.append(current.right)
            if level % 2 == 1:
                sum += sum(node.data for node in current_level)
            level += 1
        return sum

Conclusion

ISRO CS 2011 Question 51 required us to implement a binary tree data structure and its operations, and to perform a specific operation on the binary tree. By breaking down the problem into smaller sub-problems, we were able to successfully solve the problem.