Consider the following set of integers.

{20,25,57,48,37,12,92,86,33}

If one uses the quick sort algorithm to sort the above set of integers, how many p to completely sort the file?

• 5

• 8

• 3

• 9

Mergesort makes two recursive calls. Which statement is true after these recursive calls finish, but before the merge step ?

• Elements in each half of the array are sorted themselves

• Array elements form a heap

• Elements in first half are greater than second half

• None of these

A newspaper route has recently been computerized. Information about each of the 100 customers is stored in individual records containing first name, last name, and payment due. In writing a computer program to process the customer records, the programmer is uncertain whether to add a procedure to sort the records.If the records are first sorted, what will be the maximum number of comparisons needed with a binary search to find a particular customer's record? ?

• 7

• 5

• 50

• 100

How can you improve the best case efficiency in bubble sort? (The input is already sorted)

• boolean swapped = false;

  for(int j=arr.length-1; j>=0 && swapped; j--)

  {

  swapped = true;

  for(int k=0; k<j; k++)

  {

  if(arr[k] > arr[k+1])

  {

  int temp = arr[k];

  arr[k] = arr[k+1];

  arr[k+1] = temp;

  swapped = false;

  }

  }

  }

• boolean swapped = true;

  for(int j=arr.length-1; j>=0 && swapped; j--)

  {

  swapped = false;

  for(int k=0; k<j; k++)

  {

  if(arr[k] > arr[k+1])

  {

  int temp = arr[k];

  arr[k] = arr[k+1];

  arr[k+1] = temp;

  }

  }

  }

• boolean swapped = true;

  for(int j=arr.length-1; j>=0 && swapped; j--)

  {

  swapped = false;

  for(int k=0; k<j; k++)

  {

  if(arr[k] > arr[k+1])

  {

  int temp = arr[k];

  arr[k] = arr[k+1];

  arr[k+1] = temp;

  swapped = true;

  }

  }

  }

• boolean swapped = true;

  for(int j=arr.length-1; j>=0 && swapped; j--)

  {

  for(int k=0; k<j; k++)

  {

  if(arr[k] > arr[k+1])

  {

  int temp = arr[k];

  arr[k] = arr[k+1];

  arr[k+1] = temp;

  swapped = true;

  }

  }

  }

What is recurrence for worst case of QuickSort and what is the time complexity in Worst case?

• Recurrence is T(n) = T(n-2) + O(n) and time complexity is O(n^2)

• Recurrence is T(n) = 2T(n/2) + O(n) and time complexity is O(nLogn)

• Recurrence is T(n) = T(n-1) + O(n) and time complexity is O(n^2)

• Recurrence is T(n) = T(n/10) + T(9n/10) + O(n) and time complexity is O(nLogn)

Suppose we have a O(n) time algorithm that finds median of an unsorted array. Now consider a QuickSort implementation where we first find median using the above algorithm, then use median as pivot. What will be the worst case time complexity of this modified QuickSort.

• O(n^2 Logn)

• BO(n^2)

• CO(n Logn Logn)

• O(nLogn)

The number of elements that can be sorted in o(log n) time using heap sort is

• o(1)

• o( $\sqrt{\log n}$  )

• o(Log n/log log n)

• o(Log n)

Suppose we are sorting an array of eight integers using quicksort, and we have just finished the first partitioning with the array looking like this:

1 4 0 6 8 11 10 9

Which of the following statement is correct?

• The pivot could be either the 6 or the 8.

• The pivot could be the 6, but it is not the 8

• The pivot is not the 6, but it could be the 8

• Neither the 6 nor the 8 is the pivot.

Suppose we are sorting an array of eight integers using heapsort, and we have just finished some heapify (either maxheapify or minheapify) operations. The array now looks like this: 16 14 15 10 12 27 28 How many heapify operations have been performed on root of heap and what type of heap is that?

• 1 and minheap

• 2 and maxheap

• 4 or 5 minheap

• 5 or 6 max heap

Quicksort is run on two inputs shown below to sort in ascending order taking first element as pivot,

(i) 1, 2, 3,......., n

(ii) n, n-1, n-2,......, 2, 1

• C1 < C2

• C1 > C2

• C1 = C2

• We cannot say anything for arbitrary n