How to sort n dimensional list into one list with efficient way

Question

input [[1,4,5],[1,3,4],[2,6]]

output [1,1,2,3,4,4,5,6]

I have done a baby way by putting each value in to one process list which takes 2 loops and another loop for sorting

Is there any way to do it within O(n) or as fast as possible or not with using any function

def sortmerge(inputList):
    processList = []
    sortedList= []
    for i in range(len(inputList)):
        for j in range(len(inputList[i])):
            processList.append(inputList[i][j])
    # processList.sort()
    while processList:
        minimum = processList[0] 
        for x in processList: 
            if x < minimum:
                minimum = x
        sortedList.append(minimum)
        processList.remove(minimum)
    return sortedList

Just do a n-way merge: https://stackoverflow.com/questions/5055909/algorithm-for-n-way-merge — rdas, May 19 '21 at 13:28
update* my way on post // sub list might not be sorted at first — khemmawhy, May 19 '21 at 13:35
The sub lists might *not* be sorted?! Then you're asking for a general O(n) sorting algorithm, which is pie in the sky. — deceze, May 19 '21 at 13:36
Unless you can make more guarantees about your values, the most efficient in terms of speed and programmer time (not necessarily big-O though) is probably `sorted(itertools.chain.from_iterable(input))`. — deceze, May 19 '21 at 13:38
Do I need to import anything? ``` return sorted(chain.from_iterable(inputList)) NameError: name 'chain' is not defined ``` — khemmawhy, May 19 '21 at 13:43

score 0 · Answer 1 · answered May 19 '21 at 16:22

According to your comment, the sub-lists might not be sorted. Therefore, O(n) is not possible since sorting is required, but you can get O(n log n) by flattening then sorting.

from itertools import chain

inputList = [[1, 4, 5], [1, 3, 4], [2, 6]]
print(sorted(chain.from_iterable(inputList)))  # -> [1, 1, 2, 3, 4, 4, 5, 6]

(sorted() uses TimSort, which is O(n log n), and chaining is O(n).)

There might be faster ways than this if you can make more guarantees about your input data. For example, if only a few sublists might be unsorted, it could be faster to sort them, then merge.

_{Due credit to deceze for posting this solution in a comment}

How to sort n dimensional list into one list with efficient way

1 Answers1