GATE-CS-2001 Question 26

The GATE-CS-2001 Question 26 is a programming question that tests the understanding and proficiency of a programmer in solving a problem related to trees and arrays. It provides an opportunity for programmers to showcase their skills in algorithm design and implementation.

Problem Description

The question describes a binary tree where each node contains an integer value. The task is to write a function that takes an input array of integers and constructs a binary tree in such a way that the value of each node is set to the sum of all the elements in the input array that are greater than the value of the node. The function should return the root of the constructed binary tree.

Example

Input:

Array: [1, 2, 3, 4, 5]

Output:

Constructed binary tree:
     15
    /  \
   11   7
  /  \ 
 9    5
/  
1

Approach

To solve this problem, we can use a recursive approach. We start by finding the maximum value in the input array and create a new node with this value. We partition the array into two parts: one containing all the elements greater than this value and the other containing all the elements less than or equal to this value.

Next, we recursively construct the left and right subtrees by calling the same function on the subarrays containing the elements greater than the current node value and the elements less than or equal to the current node value, respectively.

Finally, we set the value of the current node to the sum of all the elements in the original array that are greater than the current node value.

Pseudocode

The following is the pseudocode to solve this problem:

function constructBinaryTree(array):
    if array is empty:
        return null
    max_value = maximum value in array
    root = create new node with max_value
    partition_array(array, max_value, greater_array, lesser_array)
    root.left = constructBinaryTree(greater_array)
    root.right = constructBinaryTree(lesser_array)
    root.value = sum of all elements in array greater than max_value
    return root

Complexity Analysis

The time complexity of constructing the binary tree using this approach is O(n^2), where n is the number of elements in the input array. This is because for each node, we partition the array by iterating over all the elements.

The space complexity is O(n) as we use recursion, and in the worst-case scenario, the height of the binary tree is n.

Conclusion

The GATE-CS-2001 Question 26 is an interesting problem that challenges programmers to design and implement a recursive algorithm to construct a binary tree based on a given input array. By understanding and applying the concepts of trees and arrays, programmers can successfully solve this problem and demonstrate their programming skills.