http://www.geeksforgeeks.org/merge-k-sorted-arrays/

Suppose there are $\lceil \log n \rceil$ sorted lists of $\lfloor n /\log n \rfloor$ elements each. The time complexity of producing a sorted list of all these elements is: (Hint:Use a heap data structure)

- $O(n \log \log n)$
- $\Theta(n \log n)$
- $\Omega(n \log n)$
- $\Omega\left(n^{3/2}\right)$

### 10 Comments

http://www.geeksforgeeks.org/merge-k-sorted-arrays/

https://www.interviewbit.com/problems/merge-two-sorted-lists-ii/

## 14 Answers

Correct Answer: $A$

### 22 Comments

Sorry Arjun Sir, but I am bit confused in it.

Yes, Saurabh is right that to preserve heap property, taking out min element will take O(logN) time ( so here it is loglogn ). But how this deletion is actually working here in this question??

1. We have created min-heap with O(log n) by considering the first element in each sorted list

2. In order to take out min element (deleting) will be down by swapping min with last element... So, here are we swapping the entire two nodes or just 2 elements???? It cannot be elements, because then sorted order cannot be maintained in each node AND how can it even be entire node swap? because after swap, in order to delete min element ( which is start of the list) we have to take it to the last through n/log(n) elements (or shift rest of the list to left by 1 position) and the go for preserving the heap property. So, answer will change in this case. (Kindly note that, if we ignore this fact on shifting.. Then I am getting the correct answer as nloglog(n) )

Can you clarify where am I going wrong??

all the logn lists are already sorted in given question... So there is no need to consider them as min heap & apply deletion of logN time... You can select the next minimum element in O(1) time by looking at 2nd element of list who's first element (min element among all the n elements) is deleted...

all the logn lists are already sorted in given question... So there is no need to consider them as min heap & apply deletion of logN time... You can select the next minimum element in O(1) time by looking at 2nd element of list who's first element (min element among all the n elements) is deleted...

Shaik Masthan sir,

I'm confused with these following approach.

3-way merge means, all 3 lists will be merged into a single list in one level.

4-way merge means, all 4 lists will be merged into a single list in one level.

k-way merge means, all k lists will be merged into 1 list in one level.

like that, logn way merge means, all logn lists will be merged into a single list in one level.

**Approach - 1**

In case of 2-way merge we're doing like this - when 2 lists of size m & n are present & we merge them in O(m+n) time where m+n is the total no. of comparison.

like wise there are logn lists, each one having n/logn elements.

$\frac{n}{logn}$, $\frac{n}{logn}$, $\frac{n}{logn}$,........................logn times

so, T.C is $O(\frac{n}{logn}+\frac{n}{logn}+\frac{n}{logn}+.........logn)$

T.C is $O(\frac{n}{logn}*logn)$ = O(n)

**Approach-2**

see, there are total n elements in the output array,

for each of these n elements, we need atmost logn comparison(as we're using logn lists to compare)

hence, T.C = O(nlogn)

please help. I'm confused

see direct k-way merge here - https://en.wikipedia.org/wiki/K-way_merge_algorithm

time complexity is given as O(nk), which means for 3-way mege we can do like this O(m+n+p)

@Shaik Masthan sir

As maximum comments are referring for 2-way merge sort even though question specifically mentioned for $heap.$ Here in this case both the approaches are giving same answer.

My question--if there is a change in the question in the # of sorted list and # of elements in each sorted list. Does both the approaches still gives the same answer. As making use of 2-way MS is easy compared to think in terms of heap. Please help me out.

@MRINMOY_HALDER, According to your second approach time complexity is greater than when heap is used.

In approach 2,

You are not finding time complexity you are finding total number of elements..

2- way merge sort will merge 2 lists each from logn lists in level 1,

in level 2:: we have logn/2 lists with each list of size 2*(n/logn)...

in level 3:: we have (logn/$2^{2}$) lists with size 4*(n/logn)

.... so on till level k when there will be 1 single list..

in level k we have (logn/$2^{k}$) lists with size $2^{k}$*(n/logn)therefore,

logn/$2^{k}$=1

logn= $2^{k}$ and k= loglogn..(Total Passes/Height of the tree)

Cost at each level/No of elements=n.

Hence T.C= cost at each level * height= O(n*loglogn)..

So, according to me merge sort gives same result. Please tell me if I'm wrong.

We can merge x arrays of each size y in in O(xy*Logy) time using Min Heap.

x = n/Logn

y = Logn

We get O(n/Logn * Logn * Log Log n) which is O(nLogLogn)

Take the pair appraoch( like merge in pairs , (1,2) is first pair , (3,4) is the second pair , (4,5) , (6,7)...... (log(n) - 1,logn) will be the log(n)/2 th pair and merge using merge procedure of mergesort which takes Theta(k) where k is the number of elements in big one list.

Thus for first attempt the work will be [ ( n/log(n) ) * ( log(n)/2 ) ]= n/2 as theta(n/log(n)) work has to be done for each pair and total log(n)/2 pairs are there

Second attempt , as now we have ( log(n)/2 ) list so again make pairs but now element in each list is 2n/log(n)

thus work will be => ( 2n/logn) * (log(n)/4 ) = n/2

similliarly again number of list will be half then make pairs thus for third attempt work will

be = (4n/logn) * (log(n)/8) = n/2

and so on....

total log(logn) attempt will be there , after that we will get single list of n elements

Thus (n/2 + n/2 + n/2 + ....... log(logn) terms )

thus ans = (n/2)* ( log(logn) ) = n log(logn)

Please correct me if I am wrong.

- See, if we use merge sort algorithm then it uses divide and conquer mechanism and divide the list into small parts and then merge them by using merge procedure.
- Now in any level, there is n/logn elements in the array and we need to merge them. To merge two array of size n/2 merge procedure take O(n/2+n/2) = O(n) time.
- So to merge two array of size n/logn it will take 2n/logn time.
- Now total number of such pair will be number of array/2 =logn/2
- so in each level total number of comparison/movement will be sum of comparison/movement of all the pairs.
- Total number of pairs = logn/2
- each pair take 2n/logn time to get merge.
- So total time taken at each level will be (2n/logn)*logn/2 =n.
- Now the depth of the tree formed by merge sort while dividing the problem into subproblem is equal to logm for m elements.
- So for logn elements the depth of tree will be loglogn.
- Now we merge each pair until it get merge till the root level of the tree so total loglogn level require and each level take time equals to n
- So total time taken will be O(nloglogn)

to merge them we will need, O( n+n ) = O (2n)

similarly to merge k list of size n = O ( kn )

Now to merge log(n) lists of size n/log(n)

it will take O ( log(n) * n / log(n) ) = O ( n )

### 3 Comments

If merge was to be done only once it would be O(n).

This is my understanding of the question, please correct me if I am wrong.

ya you are also making a good point here,

for first merge its = O ( 2n )

second = O ( 3n )

ans so on for (k-1)th merge = O ( kn )

---------------------------------------------

in total = O ( 2n + 3n + ......+ kn ) = O ( k^{2} n )

so in case of this question = O ( log^{2}(n) * n / log(n) ) = O ( n * log(n) )