Реализуйте функцию, которая принимает несколько отсортированных по возрастанию слайсов целых чисел и объединяет их в один отсортированный слайс.

Объединяйте слайсы попарно по принципу merge sort. Каждое слияние линейно, а сбалансированные уровни дают O(N log k) для N элементов в k слайсах.

Вариант на Go сохраняет повторы и не меняет входные слайсы:

func mergeSorted(groups [][]int) []int {
    if len(groups) == 0 { return []int{} }
    work := append([][]int(nil), groups...)
    for len(work) > 1 {
        next := make([][]int, 0, (len(work)+1)/2)
        for p := 0; p < len(work); p += 2 {
            if p+1 == len(work) {
                next = append(next, work[p])
                continue
            }
            a, b := work[p], work[p+1]
            out := make([]int, 0, len(a)+len(b))
            i, j := 0, 0
            for i < len(a) && j < len(b) {
                if a[i] <= b[j] {
                    out = append(out, a[i]); i++
                } else {
                    out = append(out, b[j]); j++
                }
            }
            out = append(out, a[i:]...)
            out = append(out, b[j:]...)
            next = append(next, out)
        }
        work = next
    }
    return append([]int{}, work[0]...)
}

Для k=1 выполняется копирование O(N); суммарное время учитывает также O(k) пустых входов. Живая дополнительная память O(N+k), не считая ещё не собранных GC промежуточных массивов. Альтернатива — min-heap по головам слайсов.