4/30    Sorting question!  I have n sorted arrays of doubles.  What's the
        fastest way to sort them into 1 big sorted array?
        \_ as mentioned below: you are describing one half of mergesort
        \_ You really have to ask this question?
           \_ You don't know either, huh?
        \_ If three are n sorted arrays of m doubles each, I think the fastest
           way is O(m * n log n).
              \_ Read up on mergesort, now do the logical next step.
                 \_ Mergesort doesn't take advantage of the arrays being
                    sorted.  You only need to consider the first unprocessed
                    value per array when choosing the next to insert.
                    \_ The second half of mergesort takes advantage of
                       the arrays being sorted.  That's the whole deal
                       with mergesort.  You merge two sorted lists, starting
                       with the trivial case of a single element list.
                       \_ If each sorted array has m doubles, is the complexity
                          for this O(n^2 * m)?  -- yuen
                          \_ No, it depends on you make your max function work.
                             I can think of a pretty simple way to do it
                             in O(mnlogn).
                             \_ Hell, you could just jam the lists together
                                and do a mergesort with the starting list
                                size of m (if the lists are all the same
                                length, add a null list terminator if that's
                                the case.)
                                There's tons of ways to do this all close
                                enough to the same big O that the ultimate
                                "fastest" is going to depend on real
                                limitations like is your data so large that
                                it spans multiple file systems.
              \_ I don't exctly have a pattern handy, but it should be pretty
                 easy.
        \_ http://en.wikipedia.org/wiki/Bogosort