Font size
WorksheetsSorting - IV year
Total questions: 20
Worksheet time: 12mins
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( logn )
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
Which one of the following is the recurrence equation for the worst case time complexity of the Quicksort algorithm for sorting n(≥ 2) numbers? In the recurrence equations given in the options below, c is a constant.
T(n) = 2T (n/2) + cn
T(n) = 2T (n – 2) + cn
T(n) = T(n – 1) + T(0) + cn
T(n) = T(n/2) + cn
After partial sorting, shell sorting use which sorting to sort the half sorted elements?
No Such Specific Method
Selection Sort
Insertion Sort
Heap Sort as it would work fine with Semi sorted scenario.
In Sorting, Inversion count determines whether it is a best case or average case or best case.
True
False
One of the Greedy Algorithm in Sorting is
Selection
Insertion
Merge
Quick
You have to sort a list L, consisting of a sorted list followed by a few ‘random’ elements. Which of the following sorting method would be most suitable for such a task?
Bubble sort
Selection sort
Quick sort
Insertion sort
You have to sort 1 GB of data with only 100 MB of available main memory. Which sorting technique will be most appropriate?
Heap
Merge
Quick
Selection
In quick sort, for sorting n elements, the (n/4)th smallest element is selected as pivot using an O(n) time algorithm. What is the worst case time complexity of the quick sort? (A) (n) (B) () (C) () (D) ()
O(n)
O(nLogn)
O(n^2)
O(n^2 log n)
Which of the following is true about merge sort?
Merge Sort works better than quick sort if data is accessed from slow sequential memory.
Merge Sort is stable sort by nature
Merge sort outperforms heap sort in most of the practical situations.
Consider the Quicksort algorithm. Suppose there is a procedure for finding a pivot element which splits the list into two sub-lists each of which contains at least one-fifth of the elements. Let T(n) be the number of comparisons required to sort n elements. Then
T(n) <= 2T(n/5) + n
T(n) <= T(n/5) + T(4n/5) + n
T(n) <= 2T(4n/5) + n
T(n) <= 2T(n/2) + n
Sorting Algorithm that would run in its best version with the time complexity just like a poor searching algorithm is? what is the time complexity?
Heap n
Radix nk
Bubble n
Selection n^2
