Searching & Sorting GATE CS PYQ Quiz (original) (raw)

You have an array of n elements. Suppose you implement quick sort by always choosing the central element of the array as the pivot. Then the tightest upper bound for the worst case performance is

Randomized quicksort is an extension of quicksort where the pivot is chosen randomly. What is the worst case complexity of sorting n numbers using randomized quicksort?

Let P be a QuickSort Program to sort numbers in ascending order using the first element as pivot. Let t1 and t2 be the number of comparisons made by P for the inputs {1, 2, 3, 4, 5} and {4, 1, 5, 3, 2} respectively. Which one of the following holds?

Consider the following array.

Which algorithm out of the following options uses the least number of comparisons (among the array elements) to sort the above array in ascending order?

Quicksort using the last element as pivot

Consider the function given below. Assume that the array listA contains n (> 0) elements, sorted in ascending order.

C++ `

#include using namespace std;

int ProcessArray(vector& listA, int x, int n) { int i = 0; int j = n - 1; while (i <= j) { int k = (i + j) / 2; if (x <= listA[k]) { j = k - 1; } if (listA[k] <= x) { i = k + 1; } } if (listA[k] == x) { return k; } else { return -1; } }

C

#include <stdio.h>

int ProcessArray(int *listA, int x, int n) { int i, j, k; i = 0; j = n-1; do { k = (i+j)/2; if (x <= listA[k]) j = k-1; if (listA[k] <= x) i = k+1; } while (i <= j); if (listA[k] == x) return(k); else return -1; }

Java

public class Main { public static int ProcessArray(int[] listA, int x, int n) { int i = 0, j = n - 1, k; do { k = (i + j) / 2; if (x <= listA[k]) j = k - 1; if (listA[k] <= x) i = k + 1; } while (i <= j); if (listA[k] == x) return k; else return -1; } }

Python

def ProcessArray(listA, x, n): i = 0 j = n - 1 while i <= j: k = (i + j) // 2 if x <= listA[k]: j = k - 1 if listA[k] <= x: i = k + 1 if listA[k] == x: return k else: return -1

JavaScript

function ProcessArray(listA, x, n) { let i = 0; let j = n - 1; let k; do { k = Math.floor((i + j) / 2); if (x <= listA[k]) j = k - 1; if (listA[k] <= x) i = k + 1; } while (i <= j); if (listA[k] === x) return k; else return -1; }

Which one of the following statements about the function ProcessArray is CORRECT?

It will run into an infinite loop when x is not in listA.
It is an implementation of binary search.
It will always find the maximum element in listA.
It will return −1 even when x is present in listA.

What is the number of swaps required to sort n elements using selection sort, in the worst case?

(Α) Θ(n)

(B) Ө(n log n)

(D) Ө(n² log n)

Let A be a sequence of 8 distinct integers sorted in ascending order. How many distinct pairs of sequences, B and C are there such that (i) each is sorted in ascending order, (ii) B has 5 and C has 3 elements, and (iii) the result of merging B and C gives A?

Consider the following C program that attempts to locate an element x in an array Y[] using binary search. The program is erroneous.

C `

f(int Y[10], int x) {
```
int i, j, k;
```
```
i = 0; j = 9;
```
```
do {
```
```
        k =  (i + j) /2;
```

        if( Y[k] < x)  i = k; else j = k;

```
    } while(Y[k] != x && i < j);
```

if(Y[k] == x) printf ("x is in the array ") ;

else printf (" x is not in the array ") ;

}

On which of the following contents of Y and x does the program fail?

Y is [1 2 3 4 5 6 7 8 9 10] and x < 10
Y is [1 3 5 7 9 11 13 15 17 19] and x < 1
Y is [2 2 2 2 2 2 2 2 2 2] and x > 2
Y is [2 4 6 8 10 12 14 16 18 20] and 2 < x < 20 and x is even

Consider the data given in above question, the correction needed in the program to make it work properly is

Change line 6 to: if (Y[k] < x) i = k + 1; else j = k-1;
Change line 6 to: if (Y[k] < x) i = k - 1; else j = k+1;
Change line 6 to: if (Y[k] <= x) i = k; else j = k;
Change line 7 to: } while ((Y[k] == x) && (i < j));

Which one of the following in place sorting algorithms needs the minimum number of swaps?

There are 13 questions to complete.

Take a part in the ongoing discussion