Question

3. For each of the following situations, name the best sorting algorithm we studied. (For one or two questions, there may be more than one answer deserving full credit, but you only need to give one answer for each.) The array is mostly sorted already (a few elements are in the wrong place).

(a) You need an O(n log n) sort even in the worst case and you cannot use any extra space except for a few local variables.

(b) The data to be sorted is too big to fit in memory, so most of it is on disk.

(c) You have many data sets to sort separately, and each one has only around 10 elements.

(d) Instead of sorting the entire data set, you only need the k smallest elements where k is an input to the algorithm but is likely to be much smaller than the size of the entire data set.

Answer 1

Q.a ) You need an O(n log n) sort even in the worst case and you cannot use

any extra space except for a few local variables.

Ans :-  Heap sort

  Time Complexity T(n) = O(nlogn)

Explanation : In form virtual binary-tree like structure, I said virtual because to form tree it

doesn't uses extra space to store address of child. Here child of an array[ I ] are

array[ 2*I +1 ] and array[ 2*I + 2 ].

Comparison takes place between it's child, parent will smaller than child.

Q.b ) The data to be sorted is too big to fit in memory, so most of it is on disk.

Ans :- Merge Sort

  Time Complexity T(n) = O(nlogn)

Explanation : Since merge sort uses two extra array as left_array[ L ] and right_array[ R ]

to store sorted elements on left side and sorted elements of right side and finally comparison

takes and merged together to form third array of size L+R which sorted.

So for this purpose merge sort uses large amount of memory. That's why it uses external space

Disk or tape.

Q.c ) You have many data sets to sort separately, and each one has only around 10

elements.

Ans :- Bucket sort

Time Complexity T(n) = O(k + n)

Explanation : Bucket sort is an algorithm for sort uniformly separated packet of elements.

here what we do..

Q.d ) Instead of sorting the entire data set, you only need the k smallest elements

where k is an input to the algorithm but is likely to be much smaller than the

size of the entire data set.

Ans :- Bubble sort

Time Complexity T(n) = O(k*n)

Explanation : In Bubble sort, let arr[n] be an array of size n. We have two loops

1) outer loop varies from 0 to k-1. it runs only k times. Iterator as I i.e. for( I = 0; I < K; I++)

2) inner loop varies from n-1 to 0. it runs n times. Iterator as J i.e. for( J = n-1; J > 0; J--)

3) on every iteration of I,comparison takes place from last element i.e. Jth & (J-1)th element.

a) we check arr[J-1] > arr[J], if holds true swap then

b) this will continues till value of J became 0.

4) finally we iterator for I =0 to I = K-1 and prints each elements as they are K smallest elements.

Please upvote if it helps. Feel free to comment if you have any query.

***thank you***