# Data Structures and Algorithms | Set 38

This topic contains basic questions of Algorithm which can be helpful for GATE CS Preparation. So, it is recommended to solve each of these questions if you are preparing for GATE.

**Ques-1:** Which one of the following correctly determines the solution of the recurrence relation given below with T(1) = 1 ?

T(n)= 2T(n/4) + n^{1/2}

**(A)** O(n^{2})

**(B)** O(n)

**(C)** O(n^{1/2} log n)

**(D)** O(log n)

**Explanation:**

According Master Theorem,

T(n)= 2T(n/4) + n^{1/2}

Applying Masters Theorem,

Here,

a = 2, b = 4, K = 1/2, and p = 0 So, b^{K}= 4^{1/2}= 2 Thus, a = b^{K}and (p > -1)

So, the formula is,

T(n)= O(n^{logba}log^{(P+1)}n)

Therefore,

T(n) = O(n^{log 42}log^{(0 + 1)}n) = O(n^{1/2}log n)

So, option (C) is correct.

**Ques-2:** For merging two unsorted list of size p and q into sorted list of size (p + q). The time complexity in terms of number of comparisons is:

**(A)** O(log p + log q)

**(B)** O(p log p) + q log q)

**(C)** O(p + q)

**(D)** None

**Explanation:**

For sorting the array of size p individually it takes O(p log p) and the array of size q takes O(q log q) time, then merging will take O(m + n) time.

Therefore, total number of comparisons

= O(p log p) + O(q log q) + p + q = O(p log p) + O(q log q)

So, option (B) is correct.

**Ques-3:** Which of the following sorting algorithms has the highest best case time complexity using array data structure ?

**(A)** Heap sort

**(B)** Insertion sort

**(C)** Bubble sort

**(D)** Selection sort

**Explanation:**

Best case time complexity of Heap sort is O(n log n)

Best case time complexity of Insertion sort is O(n)

Best case time complexity of Bubble sort is O(n)

Best case time complexity of selection sort is O(n^{2}).

So, option (D) is correct.

**Ques-4:** Which of the following input gives the best case time for selection sort ?

**(A)** 1 2 3 4 5 6 7 8 9

**(B)** 2 3 1 5 9 7 8 6

**(C)** 9 8 7 6 5 4 3 2 1

**(D)** All of the above take same amount of time.

**Explanation:**

Selection sort in worst case and best case takes same time.

So, option (D) is correct.

**Ques-5:** What is the time complexity of recursive function given below:

T(n)= 4T(n/2) + n^{2}

**(A)** O(n^{2})

**(B)** O(n)

**(C)** O(n^{2} log n)

**(D)** O(n log n)

**Explanation:**

According Master Theorem,

Here,

a = 4, b = 2, k = 2, p = 0 So, b^{k}= 4 i.e., a = b^{k}

Therefore, the formula is

T(n) = O(n^{log ba }log^{(P+1)}n) So, T(n)= O(n^{log 24}log^{(0 + 1)}n) = O(n^{2}log n)

So, option (C) is correct.

## Recommended Posts:

- Data Structures and Algorithms | Set 37
- Data Structures and Algorithms | Set 29
- Data Structures and Algorithms | Set 28
- Data Structures and Algorithms | Set 36
- Data Structures and Algorithms | Set 33
- Data Structures and Algorithms | Set 35
- Data Structures and Algorithms | Set 34
- Data Structures and Algorithms | Set 32
- Data Structures and Algorithms | Set 31
- Data Structures and Algorithms | Set 21
- Data Structures and Algorithms | Set 20
- Data Structures and Algorithms | Set 19
- Data Structures and Algorithms | Set 18
- Data Structures and Algorithms | Set 16
- Data Structures and Algorithms | Set 22

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.