Merge algorithm

related topics
{math, number, function}
{system, computer, user}
{area, part, region}
{rate, high, increase}

Merge algorithms are a family of algorithms that run sequentially over multiple sorted lists, typically producing more sorted lists as output. This is well-suited for machines with tape drives. Use has declined due to large random access memories, and many applications of merge algorithms have faster alternatives when a random-access memory is available.[citation needed]

The general merge algorithm has a set of pointers p0..n that point to positions in a set of lists L0..n. Initially they point to the first item in each list. The algorithm is as follows:

While any of p0..n still point to data inside of L0..n instead of past the end:

Analysis

Merge algorithms generally run in time proportional to the sum of the lengths of the lists; merge algorithms that operate on large numbers of lists at once will multiply the sum of the lengths of the lists by the time to figure out which of the pointers points to the lowest item, which can be accomplished with a heap-based priority queue in O(log n) time, for O(m log n) time, where n is the number of lists being merged and m is the sum of the lengths of the lists. When merging two lists of length m, there is a lower bound of 2m − 1 comparisons required in the worst case.

The classic merge (the one used in merge sort) outputs the data item with the lowest key at each step; given some sorted lists, it produces a sorted list containing all the elements in any of the input lists, and it does so in time proportional to the sum of the lengths of the input lists.

In parallel computing, arrays of sorted values may be merged efficiently using an all nearest smaller values computation.[1]

Language support

The C++'s Standard Template Library has the function std::merge, which merges two sorted ranges of iterators, and std::inplace_merge, which merges two consecutive sorted ranges in-place. In addition, the std::list (linked list) class has its own merge method which merges another list into itself. The type of the elements merged must support the less-than (<) operator, or it must be provided with a custom comparator.

Python (programming language)'s standard library (since 2.6) also has a merge() function in the heapq module, that takes multiple sorted iterables, and merges them into a single iterator.[1]

References

  • Donald Knuth. The Art of Computer Programming, Volume 3: Sorting and Searching, Third Edition. Addison-Wesley, 1997. ISBN 0-201-89685-0. Pages 158–160 of section 5.2.4: Sorting by Merging. Section 5.3.2: Minimum-Comparison Merging, pp.197–207.

Full article ▸

related documents
Finitely generated abelian group
Cauchy's integral theorem
Atlas (topology)
Wreath product
Commutative diagram
Addition of natural numbers
Hilbert's basis theorem
Sather
NC (complexity)
Symmetric tensor
Directed set
Axiom of extensionality
BQP
Symbolic logic
Removable singularity
Interpreted language
Catalan's conjecture
Constant term
Linear prediction
Vector calculus
Nilpotent group
Bucket sort
Recursively enumerable language
Matrix addition
Generating set of a group
Haar wavelet
Infinite set
Non-deterministic Turing machine
Canonical LR parser
List of small groups