Assumptions
The following method works with any container like array, vector, list etc. I'm assuming that we are working with lists.
Let's assume that we have m sorted lists which we want to merge.
Let n denotes the total number of elements in all lists.
Idea
The first element in the resulting list has to be the smallest element in the set of all heads of the lists.
The idea is quite simple. Just select the smallest head and move it from the original list to the result. You want to repeat that routine while there is at least one non empty list. The crucial thing here is to select the smallest head fast.
If m is small
A linear scan through the heads is O(m) resulting in O(m * n) total time which is fine if m is a small constant.
If m is not so small
Then we can do better by using a priority queue, for example a heap. The invariant here is that the smallest element in the heap is always the smallest element from current heads.
Finding the minimum element is a heap is O(1), deleting the minimum is O(log m) if there are m elements in the heap, and inserting an element into the heap is also O(log m).
In summary, for each of n elements, we insert it into the heap once and delete it from there also once. The total complexity with a heap is O(n log m) which is significantly faster that O(n * m) if m is not a small constant.
Summary
Which method is faster depends on how many lists we want to merge. If m is small pick the linear scan, in the other case implement it with a priority queue. Sometimes it's hard to judge if the m is small or not and in that case some experiments will be helpful.
