en>Nbarth: /* Data types */ wording

2014-01-25T07:27:48Z

Data types: wording

New page

{{Infobox Algorithm
|class=[[Sorting algorithm]]
|image=[[File:Merge-sort-example-300px.gif]]
|caption=An example of merge sort. First divide the list into the smallest unit (1 element), then compare each element with the adjacent list to sort and merge the two adjacent lists. Finally all the elements are sorted and merged.
|data=[[Array data structure|Array]]
|time=O(''n'' log ''n'')
|best-time=O(''n'' log ''n'') typical,
O(''n'') natural variant
|average-time=O(''n'' log ''n'')
|space=O(''n'') auxiliary
|optimal=Yes
}}
[[Image:Merge sort animation2.gif|right|thumb|Merge sort animation. The sorted elements are represented by dots.]]
In [[computer science]], a '''merge sort''' (also commonly spelled '''mergesort''') is an ''[[Big O notation|O]]''(''n'' log ''n'') [[comparison sort|comparison-based]] [[sorting algorithm]]. Most implementations produce a [[Sorting algorithm#Stability|stable sort]], which means that the implementation preserves the input order of equal elements in the sorted output. Mergesort is a [[divide and conquer algorithm]] that was invented by [[John von Neumann]] in 1945.<ref>{{Harvtxt|Knuth|1998|p=158}}</ref> A detailed description and analysis of bottom-up mergesort appeared in a report by [[Herman Goldstine|Goldstine]] and Neumann as early as 1948.<ref>{{cite journal |title=A meticulous analysis of mergesort programs |year=1997 |author=Jyrki Katajainen and Jesper Larsson Träff |ref=harv}}</ref>

==Algorithm==
Conceptually, a merge sort works as follows
#Divide the unsorted list into ''n'' sublists, each containing 1 element (a list of 1 element is considered sorted).
#Repeatedly [[Merge algorithm|merge]] sublists to produce new sorted sublists until there is only 1 sublist remaining. This will be the sorted list.

===Top-down implementation ===
Example C like code using indices for top down merge sort algorithm that recursively splits the list (called ''runs'' in this example) into sublists until sublist size is 1, then merges those sublists to produce a sorted list. The copy back step could be avoided if the recursion alternated between two functions so that the direction of the merge corresponds with the level of recursion.

<source lang="C">
TopDownMergeSort(A[], B[], n)
{
TopDownSplitMerge(A, 0, n, B);
}
CopyArray(B[], iBegin, iEnd, A[])
{
for(k = iBegin; k < iEnd; k++)
A[k] = B[k];
}
TopDownSplitMerge(A[], iBegin, iEnd, B[])
{
if(iEnd - iBegin < 2) // if run size == 1
return; // consider it sorted
// recursively split runs into two halves until run size == 1,
// then merge them and return back up the call chain
iMiddle = (iEnd + iBegin) / 2; // iMiddle = mid point
TopDownSplitMerge(A, iBegin, iMiddle, B); // split / merge left half
TopDownSplitMerge(A, iMiddle, iEnd, B); // split / merge right half
TopDownMerge(A, iBegin, iMiddle, iEnd, B); // merge the two half runs
CopyArray(B, iBegin, iEnd, A); // copy the merged runs back to A
}

TopDownMerge(A[], iBegin, iMiddle, iEnd, B[])
{
i0 = iBegin, i1 = iMiddle;

// While there are elements in the left or right runs
for (j = iBegin; j < iEnd; j++) {
// If left run head exists and is <= existing right run head.
if (i0 < iMiddle && (i1 >= iEnd || A[i0] <= A[i1]))
B[j] = A[i0++]; // Increment i0 after using it as an index.
else
B[j] = A[i1++]; // Increment i1 after using it as an index.
}

}
</source>

===Bottom-up implementation===

Example code for C using indices for bottom up merge sort algorithm which treats the list as an array of ''n'' sublists (called ''runs'' in this example) of size 1, and iteratively merges sub-lists back and forth between two buffers:

<source lang="C">
/* array A[] has the items to sort; array B[] is a work array */
BottomUpSort(int n, int A[], int B[])
{
int width;

/* Each 1-element run in A is already "sorted". */

/* Make successively longer sorted runs of length 2, 4, 8, 16... until whole array is sorted. */
for (width = 1; width < n; width = 2 * width)
{
int i;

/* Array A is full of runs of length width. */
for (i = 0; i < n; i = i + 2 * width)
{
/* Merge two runs: A[i:i+width-1] and A[i+width:i+2*width-1] to B[] */
/* or copy A[i:n-1] to B[] ( if(i+width >= n) ) */
BottomUpMerge(A, i, min(i+width, n), min(i+2*width, n), B);
}

/* Now work array B is full of runs of length 2*width. */
/* Copy array B to array A for next iteration. */
/* A more efficient implementation would swap the roles of A and B */
CopyArray(A, B, n);
/* Now array A is full of runs of length 2*width. */
}
}

BottomUpMerge(int A[], int iLeft, int iRight, int iEnd, int B[])
{
int i0 = iLeft;
int i1 = iRight;
int j;

/* While there are elements in the left or right lists */
for (j = iLeft; j < iEnd; j++)
{
/* If left list head exists and is <= existing right list head */
if (i0 < iRight && (i1 >= iEnd || A[i0] <= A[i1]))
{
B[j] = A[i0];
i0 = i0 + 1;
}
else
{
B[j] = A[i1];
i1 = i1 + 1;
}
}
}
</source>

===Top-down implementation using lists ===
Example [[pseudocode]] for top down merge sort algorithm which uses recursion to divide the list into sub-lists, then merges sublists during returns back up the call chain.

'''function''' merge_sort(''list'' m)
// Base case. A list of zero or one elements is sorted, by definition.
'''if''' length(m) <= 1
'''return''' m

// Recursive case. First, *divide* the list into equal-sized sublists.
'''var''' ''list'' left, right
'''var''' ''integer'' middle = length(m) / 2
'''for each''' x '''in''' m '''before''' middle
add x to left
'''for each''' x '''in''' m '''after or equal''' middle
add x to right

// Recursively sort both sublists.
left = merge_sort(left)
right = merge_sort(right)
// *Conquer*: merge the now-sorted sublists.
'''return''' merge(left, right)

In this example, the <code>merge</code> function merges the left and right sublists.

'''function''' merge(left, right)
''// receive the left and right sublist as arguments.''
''// 'result' variable for the merged result of two sublists.''
'''var''' ''list'' result
''// assign the element of the sublists to 'result' variable until there is no element to merge.''
'''while''' length(left) > 0 '''or''' length(right) > 0
'''if''' length(left) > 0 '''and''' length(right) > 0
''// compare the first two element, which is the small one, of each two sublists.''
'''if''' first(left) <= first(right)
''// the small element is copied to 'result' variable.''
''// delete the copied one(a first element) in the sublist.''
append first(left) to result
left = rest(left)
'''else'''
''// same operation as the above(in the right sublist).''
append first(right) to result
right = rest(right)
'''else if''' length(left) > 0
''// copy all of remaining elements from the sublist to 'result' variable,
''// when there is no more element to compare with.''
append first(left) to result
left = rest(left)
'''else if''' length(right) > 0
''// same operation as the above(in the right sublist).''
append first(right) to result
right = rest(right)
'''end while'''
''// return the result of the merged sublists(or completed one, finally).''
''// the length of the left and right sublists will grow bigger and bigger, after the next call of this function.''
'''return''' result

==Natural merge sort==

A natural merge sort is similar to a bottom up merge sort except that any naturally occurring runs (sorted sequences) in the input are exploited. In the bottom up merge sort, the starting point assumes each run is one item long. In practice, random input data will have many short runs that just happen to be sorted. In the typical case, the natural merge sort may not need as many passes because there are fewer runs to merge. In the best case, the input is already sorted (i.e., is one run), so the natural merge sort need only make one pass through the data. Example:

Start : 3--4--2--1--7--5--8--9--0--6
Select runs : 3--4 2 1--7 5--8--9 0--6
Merge : 2--3--4 1--5--7--8--9 0--6
Merge : 1--2--3--4--5--7--8--9 0--6
Merge : 0--1--2--3--4--5--6--7--8--9

==Analysis==
[[Image:merge sort algorithm diagram.svg|thumb|right|300px|A recursive merge sort algorithm used to sort an array of 7 integer values. These are the steps a human would take to emulate merge sort (top-down).]]

In sorting ''n'' objects, merge sort has an [[average performance|average]] and [[worst-case performance]] of [[big O notation|O]](''n'' log ''n''). If the running time of merge sort for a list of length ''n'' is ''T''(''n''), then the recurrence ''T''(''n'') = 2''T''(''n''/2) + ''n'' follows from the definition of the algorithm (apply the algorithm to two lists of half the size of the original list, and add the ''n'' steps taken to merge the resulting two lists). The closed form follows from the [[master theorem]].

In the worst case, the number of comparisons merge sort makes is equal to or slightly smaller than (''n'' ⌈[[Binary logarithm|lg]] ''n''⌉ - 2⌈lg ''n''⌉ + 1), which is between (''n'' lg ''n'' - ''n'' + 1) and (''n'' lg ''n'' + ''n'' + O(lg ''n'')).<ref>The worst case number given here does not agree with that given in [[Donald Knuth|Knuth]]'s ''[[Art of Computer Programming]], Vol 3''. The discrepancy is due to Knuth analyzing a variant implementation of merge sort that is slightly sub-optimal</ref>

For large ''n'' and a randomly ordered input list, merge sort's expected (average) number of comparisons approaches ''α''·''n'' fewer than the worst case where <math>\alpha = -1 + \sum_{k=0}^\infty \frac1{2^k+1} \approx 0.2645.</math>

In the ''worst'' case, merge sort does about 39% fewer comparisons than [[quicksort]] does in the ''average'' case. In terms of moves, merge sort's worst case complexity is [[big O notation|O]](''n'' log ''n'')—the same complexity as quicksort's best case, and merge sort's best case takes about half as many iterations as the worst case.{{Citation needed|date=June 2008}}

Merge sort is more efficient than quicksort for some types of lists if the data to be sorted can only be efficiently accessed sequentially, and is thus popular in languages such as [[Lisp programming language|Lisp]], where sequentially accessed data structures are very common. Unlike some (efficient) implementations of quicksort, merge sort is a stable sort as long as the merge operation is implemented properly.

Merge sort's most common implementation does not sort in place; therefore, the memory size of the input must be allocated for the sorted output to be stored in (see below for versions that need only ''n''/2 extra spaces).

Merge sort also has some demerits. One is its use of 2''n'' locations; the additional ''n'' locations are commonly used because merging two sorted sets in place is more complicated and would need more comparisons and move operations. But despite the use of this space the algorithm still does a lot of work: The contents of ''m'' are first copied into ''left'' and ''right'' and later into the list ''result'' on each invocation of ''merge_sort'' (variable names according to the pseudocode above).

==Variants==
Variants of merge sort are primarily concerned with reducing the space complexity and the cost of copying.

A simple alternative for reducing the space overhead to ''n''/2 is to maintain ''left'' and ''right'' as a combined structure, copy only the ''left'' part of ''m'' into temporary space, and to direct the ''merge'' routine to place the merged output into ''m''. With this version it is better to allocate the temporary space outside the ''merge'' routine, so that only one allocation is needed. The excessive copying mentioned previously is also mitigated, since the last pair of lines before the ''return result'' statement (function '' merge ''in the pseudo code above) become superfluous.

[[In-place]] sorting is possible, and still stable, but is more complicated, and slightly slower, requiring non-linearithmic [[quasilinear time]] O(''n'' log2 ''n'') One way to sort in-place is to merge the blocks recursively.<ref>[http://h2database.googlecode.com/svn/trunk/h2/src/tools/org/h2/dev/sort/InPlaceStableMergeSort.java A Java implementation of in-place stable merge sort]</ref> Like the standard merge sort, in-place merge sort is also a [[stable sort]]. Stable sorting of linked lists is simpler. In this case the algorithm does not use more space than that already used by the list representation, but the O(log(''k'')) used for the recursion trace.

An alternative to reduce the copying into multiple lists is to associate a new field of information with each key (the elements in ''m'' are called keys). This field will be used to link the keys and any associated information together in a sorted list (a key and its related information is called a record). Then the merging of the sorted lists proceeds by changing the link values; no records need to be moved at all. A field which contains only a link will generally be smaller than an entire record so less space will also be used. This is a standard sorting technique, not restricted to merge sort.

==Use with tape drives==
[[File:IBM 729 Tape Drives.nasa.jpg|thumb|Merge sort type algorithms allowed large data sets to be sorted on early computers that had small random access memories by modern standards. Records were stored on [[magnetic tape]] and processed on banks of magnetic tape drives, such as these [[IBM 729]]s.]]
An [[External sorting|external]] merge sort is practical to run using [[disk storage|disk]] or [[tape drive|tape]] drives when the data to be sorted is too large to fit into [[primary storage|memory]]. [[External sorting]] explains how merge sort is implemented with disk drives. A typical tape drive sort uses four tape drives. All I/O is sequential (except for rewinds at the end of each pass). A minimal implementation can get by with just 2 record buffers and a few program variables.

Naming the four tape drives as A, B, C, D, with the original data on A, and using only 2 record buffers, the algorithm is similar to [[#Bottom-up_implementation|Bottom-up implementation]], using pairs of tape drives instead of arrays in memory. The basic algorithm can be described as follows:

# Merge pairs of records from A; writing two-record sublists alternately to C and D.
# Merge two-record sublists from C and D into four-record sublists; writing these alternately to A and B.
# Merge four-record sublists from A and B into eight-record sublists; writing these alternately to C and D
# Repeat until you have one list containing all the data, sorted --- in log2(''n'') passes.

Instead of starting with very short runs, usually a [[hybrid algorithm]] is used, where the initial pass will read many records into memory, do an internal sort to create a long run, and then distribute those long runs onto the output set. The step avoids many early passes. For example, an internal sort of 1024 records will save 9 passes. The internal sort is often large because it has such a benefit. In fact, there are techniques that can make the initial runs longer than the available internal memory.<ref>Selection sort. Knuth's snowplow. Natural merge.</ref>

A more sophisticated merge sort that optimizes tape (and disk) drive usage is the [[polyphase merge sort]].

==Optimizing merge sort==
On modern computers, [[locality of reference]] can be of paramount importance in [[software optimization]], because multilevel [[Memory hierarchy|memory hierarchies]] are used. [[Cache (computing)|Cache]]-aware versions of the merge sort algorithm, whose operations have been specifically chosen to minimize the movement of pages in and out of a machine's memory cache, have been proposed. For example, the '''{{visible anchor|tiled merge sort}}''' algorithm stops partitioning subarrays when subarrays of size S are reached, where S is the number of data items fitting into a CPU's cache. Each of these subarrays is sorted with an in-place sorting algorithm such as [[insertion sort]], to discourage memory swaps, and normal merge sort is then completed in the standard recursive fashion. This algorithm has demonstrated better performance on machines that benefit from cache optimization. {{Harv|LaMarca|Ladner|1997}}

{{Harvtxt|Kronrod|1969}} suggested an alternative version of merge sort that uses constant additional space. This algorithm was later refined. {{Harv|Katajainen|Pasanen|Teuhola|1996}}

Also, many applications of [[external sorting]] use a form of merge sorting where the input get split up to a higher number of sublists, ideally to a number for which merging them still makes the currently processed set of [[page (computer memory)|pages]] fit into main memory.

==Parallel processing==
Merge sort parallelizes well due to use of the divide-and-conquer method. A parallel implementation is shown in pseudo-code in the third edition of Cormen, Leiserson, Rivest, and Stein's ''Introduction to Algorithms''.<ref>{{Harvnb|Cormen|Leiserson|Rivest|Stein|2009|p=803}}</ref> This algorithm uses a parallel [[merge algorithm]] to not only parallelize the recursive division of the array, but also the merge operation. It performs well in practice when combined with a fast stable sequential sort, such as [[insertion sort]], and a fast sequential merge as a base case for merging small arrays.<ref>[http://drdobbs.com/high-performance-computing/229400239 V. J. Duvanenko, "Parallel Merge Sort", Dr. Dobb's Journal, March 2011]</ref> Merge sort was one of the first sorting algorithms where optimal speed up was achieved, with Richard Cole using a clever subsampling algorithm to ensure ''O''(1) merge.<ref>{{Cite journal|first1=Richard|last1=Cole|title=Parallel merge sort|journal=SIAM J. Comput.|volume=17|issue=4|date=August 1988|pages=770–785|doi=10.1137/0217049|ref=harv|postscript={{inconsistent citations}}}}</ref> Other sophisticated parallel sorting algorithms can achieve the same or better time bounds with a lower constant. For example, in 1991 David Powers described a parallelized [[quicksort]] (and a related [[radix sort]]) that can operate in ''O''(log ''n'') time on a CRCW [[Parallel Random Access Machine|PRAM]] with ''n'' processors by performing partitioning implicitly.<ref>Powers, David M. W. [http://citeseer.ist.psu.edu/327487.html Parallelized Quicksort and Radixsort with Optimal Speedup], ''Proceedings of International Conference on Parallel Computing Technologies''. [[Novosibirsk]]. 1991.</ref> Powers<ref> David M. W. Powers, [http://david.wardpowers.info/Research/AI/papers/199501-ACAW-PUPC.pdf Parallel Unification: Practical Complexity], Australasian Computer Architecture Workshop, Flinders University, January 1995</ref> further shows that a pipelined version of Batcher's [[Bitonic_sorter|Bitonic Mergesort]] at ''O''(log2''n'') time on a butterfly [[sorting network]] is in practice actually faster than his ''O''(log ''n'') sorts on a [[Parallel_Random_Access_Machine|PRAM]], and he provides detailed discussion of the hidden overheads in comparison, radix and parallel sorting.

==Comparison with other sort algorithms==
Although [[heapsort]] has the same time bounds as merge sort, it requires only Θ(1) auxiliary space instead of merge sort's Θ(''n''). On typical modern architectures, efficient [[quicksort]] implementations generally outperform mergesort for sorting RAM-based arrays. On the other hand, merge sort is a stable sort and is more efficient at handling slow-to-access sequential media. Merge sort is often the best choice for sorting a [[linked list]]: in this situation it is relatively easy to implement a merge sort in such a way that it requires only Θ(1) extra space, and the slow random-access performance of a linked list makes some other algorithms (such as quicksort) perform poorly, and others (such as heapsort) completely impossible.

As of [[Perl]] 5.8, merge sort is its default sorting algorithm (it was quicksort in previous versions of Perl). In [[Java platform|Java]], the [http://docs.oracle.com/javase/6/docs/api/java/util/Arrays.html Arrays.sort()] methods use merge sort or a tuned quicksort depending on the datatypes and for implementation efficiency switch to [[insertion sort]] when fewer than seven array elements are being sorted.<ref>[https://openjdk.dev.java.net/source/browse/openjdk/jdk/trunk/jdk/src/share/classes/java/util/Arrays.java?view=markup OpenJDK Subversion]</ref> [[Python (programming language)|Python]] uses [[timsort]], another tuned hybrid of merge sort and insertion sort, that has become the standard sort algorithm in [[Java 7|Java SE 7]],<ref>{{cite web
| title = Commit 6804124: Replace "modified mergesort" in java.util.Arrays.sort with timsort
| url = http://hg.openjdk.java.net/jdk7/tl/jdk/rev/bfd7abda8f79
| last = jjb
| work = Java Development Kit 7 Hg repo
| accessdate = 24 Feb 2011
}}</ref> on the [[Android (operating system)|Android platform]],<ref>{{cite web
| title = Class: java.util.TimSort<T>
| url = http://www.kiwidoc.com/java/l/x/android/android/5/p/java.util/c/TimSort
| work = Android JDK 1.5 Documentation
| accessdate = 24 Feb 2011
}}{{Dead link|date=June 2013}}</ref> and in [[GNU Octave]].<ref>{{cite web
| title = liboctave/util/oct-sort.cc
| url = http://hg.savannah.gnu.org/hgweb/octave/file/0486a29d780f/liboctave/util/oct-sort.cc
| work = Mercurial repository of Octave source code
| accessdate = 18 Feb 2013
| quote = Code stolen in large part from Python's, listobject.c, which itself had no license header. However, thanks to Tim Peters for the parts of the code I ripped-off.
| at = Lines 23-25 of the initial comment block.
}}</ref>

==Utility in online sorting==
Merge sort's merge operation is useful in [[online algorithm|online]] sorting, where the list to be sorted is received a piece at a time, instead of all at the beginning. In this application, we sort each new piece that is received using any sorting algorithm, and then merge it into our sorted list so far using the merge operation.

==Notes==
{{reflist|30em}}

==References==
*{{Introduction to Algorithms|3}}
*{{Cite news
| last1 = Katajainen
| first1 = Jyrki
| last2 = Pasanen
| first2 = Tomi
| last3 = Teuhola
| first3 = Jukka
| year = 1996
| title = Practical in-place mergesort
| periodical = Nordic Journal of Computing
| volume = 3
| pages = 27–40
| url = http://www.diku.dk/hjemmesider/ansatte/jyrki/Paper/mergesort_NJC.ps
| accessdate = 2009-04-04
| issn=1236-6064
| ref = harv}}. Also [http://citeseer.ist.psu.edu/katajainen96practical.html Practical In-Place Mergesort]. Also [http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.22.8523]
* {{cite book
| last = Knuth
| first = Donald
| authorlink = Donald Knuth
| series = [[The Art of Computer Programming]]
| volume= 3
| title= Sorting and Searching
| edition = 2nd
| publisher = Addison-Wesley
| year= 1998
| chapter = Section 5.2.4: Sorting by Merging
| pages = 158–168
| isbn = 0-201-89685-0
| ref = harv}}
*{{Cite news
| last = Kronrod
| first = M. A.
| year = 1969
| title = Optimal ordering algorithm without operational field
| periodical = Soviet Mathematics - Doklady
| volume = 10
| page = 744
| ref = harv}}
*{{Cite journal
|first= A.
|last= LaMarca
|first2= R. E.
|last2= Ladner
|title= The influence of caches on the performance of sorting
|journal= Proc. 8th Ann. ACM-SIAM Symp. on Discrete Algorithms (SODA97)
|year= 1997
|pages= 370–379
|ref= harv}}
* {{cite web
| author=Sun Microsystems
|title=Arrays API
|url=http://java.sun.com/javase/6/docs/api/java/util/Arrays.html
|accessdate=2007-11-19 }}
* {{cite web
| author=Sun Microsystems
|title=java.util.Arrays.java
|url=https://openjdk.dev.java.net/source/browse/openjdk/jdk/trunk/jdk/src/share/classes/java/util/Arrays.java?view=markup
|accessdate=2007-11-19 }}

==External links==
{{wikibooks|Algorithm implementation|Sorting/Merge_sort|Merge sort}}
* [http://www.sorting-algorithms.com/merge-sort Animated Sorting Algorithms: Merge Sort] – graphical demonstration and discussion of array-based merge sort
* [http://www.nist.gov/dads/HTML/mergesort.html Dictionary of Algorithms and Data Structures: Merge sort]
* [http://www.yorku.ca/sychen/research/sorting/index.html Mergesort applet] with "level-order" recursive calls to help improve algorithm analysis
* [http://opendatastructures.org/versions/edition-0.1e/ods-java/11_1_Comparison_Based_Sorti.html#SECTION001411000000000000000 Open Data Structures - Section 11.1.1 - Merge Sort]

{{sorting}}

{{DEFAULTSORT:Merge Sort}}
[[Category:Sorting algorithms]]
[[Category:Comparison sorts]]
[[Category:Stable sorts]]
[[Category:Articles with example pseudocode]]
[[Category:Online sorts]]

[[no:Sorteringsalgoritme#Flettesortering]]

Mutual recursion - Revision history

en>Ldionne92: Add missing braces to C function definition.

67.169.93.106: /* Computer functions */

en>Nbarth: /* Data types */ wording