GATE CS 2017 (Set 1) - Question 47

Introduction

This question is from the Computer Science Graduate Aptitude Test in Engineering (GATE) 2017 (Set 1) exam. The question is related to data structures and algorithms.

Problem Statement

Suppose we are given a set of n elements and an unsorted array A of n distinct integers. We want to sort the array using a Merge-Sort like algorithm.

We recursively divide the array into two halves until each array contains only one element. Then we merge the sub-arrays in a way such that the resulting array is sorted.

However, we are only able to merge two sub-arrays if the maximum element in the left sub-array is less than the minimum element in the right sub-array.

The problem is to find the largest number k such that any given set of n distinct elements, we can always sort them using at most this many such operations.

Solution

Given the above problem statement, we can write a recursive algorithm to solve it.

We start by dividing the array A into two sub-arrays, and recursively apply the same algorithm on each sub-array. If the maximum element in the left sub-array is less than or equal to the minimum element in the right sub-array, we can merge the sub-arrays and obtain a sorted array.

However, if the maximum element in the left sub-array is greater than the minimum element in the right sub-array, then we need to repeat the process by dividing the sub-array into two sub-arrays until we find two sub-arrays satisfying the property that the maximum element in the left sub-array is less than or equal to the minimum element in the right sub-array.

The maximum number of operations required to sort an array of n elements using this algorithm can be found using a recursive formula.

Let T(n) denote the maximum number of operations required to sort an array of n elements using the above algorithm. Then,

T(n) = 2T(n/2) + 1

where, n is the number of elements in the array.

Based on the above recursive formula, we can derive the time complexity of the algorithm as follows.

T(n) = 2T(n/2) + 1

• = 2^2 T(n/2^2) + 2^1 + 1*

• = 2^3 T(n/2^3) + 2^2 + 2^1 + 1*

• = ...*

• = 2^k T(n/2^k) + 2^(k-1) + 2^(k-2) + ... + 2 + 1*

• = n + log n - 1*

Thus, the time complexity of the algorithm is O(n log n).

Conclusion

In this question, we discussed a recursive algorithm to sort an array using the Merge-Sort like algorithm with a given condition. We also derived a recursive formula for finding the maximum number of operations required to sort an array of n elements using this algorithm. The time complexity of the algorithm was also derived to be O(n log n).