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

While any of p_{0..n} still point to data inside of L_{0..n} instead of past the end:

- do something with the data items p
_{0..n}point to in their respective lists - find out which of those pointers points to the item with the lowest key; advance one of those pointers to the next item in its list

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.

Merge can also be used for a variety of other things:

- given a set of current account balances and a set of transactions, both sorted by account number, produce the set of new account balances after the transactions are applied; this requires always advancing the "new transactions" pointer in preference to the "account number" pointer when the two have equal keys, and adding all the numbers on either tape with the same account number to produce the new balance.
- produce a sorted list of records with keys present in all the lists (equijoin); this requires outputting a record whenever the keys of all the p
_{0..n}are equal. - similarly for finding the largest number on one tape smaller than each number on another tape (e.g. to figure out what tax bracket each person is in).
- similarly for computing set differences: all the records in one list with no corresponding records in another.