Question

I need a recommendation for a good implementation of merge sort in Java.
Basically, I can write all the merges but if I would have a good jar from a provider such as Apache or Google it would be nicer.

Requirements for the merge sort:

1. I get an unknown number of sorted arrays.
2. Very important: I get a number that says when to stop (lets say it says 34 on a random incident – I want my algorithm to stop sorting when it reaches that number).

No need to write the code here, I’m only looking for an available jar/library.

Answer 1

I don’t know of a ready-made solution, but it appears simple enough to implement with the help of a priority queue:

import static java.util.Arrays.asList;

import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.PriorityQueue;

public class MergingIterator<T> implements Iterator<T> {

    public static class InputIter<T> {
        final Iterator<T> source;
        T data;

        public InputIter(Iterable<T> list) {
            source = list.iterator();
            read();
        }

        public void read() {
            if (source.hasNext()) {
                data = source.next();
            } else {
                data = null;
            }
        }
    }

    final PriorityQueue<InputIter<T>> queue;

    public MergingIterator(final Comparator<? super T> cmp, Iterable<T>... lists) {
        queue = new PriorityQueue<InputIter<T>>(lists.length, new Comparator<InputIter<T>>() {
            @Override
            public int compare(InputIter<T> o1, InputIter<T> o2) {
                return cmp.compare(o1.data, o2.data);
            }
        });
        for (Iterable<T> list : lists) {
            InputIter<T> ii = new InputIter<T>(list);
            if (ii.data != null) {
                queue.add(ii);
            }
        }
    }

    @Override
    public boolean hasNext() {
        return !queue.isEmpty();
    }

    @Override
    public T next() {
        InputIter<T> ii = queue.poll();
        T next = ii.data;
        ii.read();
        if (ii.data != null) {
            queue.add(ii);
        }
        return next;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }
}

Test code:

    Comparator<Integer> cmp = new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    };
    List<Integer> empty = asList();
    Iterator<Integer> iter = new MergingIterator<Integer> (
        cmp,
        asList(1, 2, 4, 5, 7, 8),
        asList(3),
        asList(6, 9),
        asList(0),
        empty
    );

    while (iter.hasNext()) {
        System.out.println(iter.next());
    }

The space complexity is O(L), and the time complexity is O((L + K) log(L)) where L is the number of lists, and K the number of retrieved elements.