Merge sort
Divide and conquer sorting algorithm
- 34 min read
- 9 chapters
Related on Lably
Through Pseudocode, Best, worst and average case and Big O notation
Algorithm
Conceptually, a merge sort works as follows:
- Divide the unsorted list into n sub-lists, each containing one element (a list of one element is considered sorted).
- Repeatedly merge sublists to produce new sorted sublists until there is only one sublist remaining. This will be the sorted list.
Merge sort is efficient because merging and sorting two sublists can be performed in linear time, provided that the sublists are already sorted.
Top-down implementation
Example C-like code using indices for top-down merge sort algorithm that recursively splits the list into sublists (called runs in this example) until sublist size is 1, then merges those sublists to produce a sorted list. The copy back step is avoided with alternating the direction of the merge with each level of recursion (except for an initial one-time copy, that can be avoided too).
As a simple example, consider an array with two elements. The elements are copied to b, then merged back to a. If there are four elements, when the bottom of the recursion level is reached, single element runs from a are merged to b, and then at the next higher level of recursion, those two-element runs are merged to a. This pattern continues with each level of recursion.
<span id="mwNA"></span><span class="c1" id="mwNQ">// Copy a section of the array a into array b (from begin to end - 1)</span> <span class="kt" id="mwNg">void</span><span class="w" id="mwNw"> </span><span class="nf" id="mwOA">copyArray</span><span class="p" id="mwOQ">(</span><span class="kt" id="mwOg">int</span><span class="o" id="mwOw">[]</span><span class="w" id="mwPA"> </span><span class="n" id="mwPQ">a</span><span class="p" id="mwPg">,</span><span class="w" id="mwPw"> </span><span class="kt" id="mwQA">int</span><span class="w" id="mwQQ"> </span><span class="n" id="mwQg">begin</span><span class="p" id="mwQw">,</span><span class="w" id="mwRA"> </span><span class="kt" id="mwRQ">int</span><span class="w" id="mwRg"> </span><span class="n" id="mwRw">end</span><span class="p" id="mwSA">,</span><span class="w" id="mwSQ"> </span><span class="kt" id="mwSg">int</span><span class="o" id="mwSw">[]</span><span class="w" id="mwTA"> </span><span class="n" id="mwTQ">b</span><span class="p" id="mwTg">)</span><span class="w" id="mwTw"> </span><span class="p" id="mwUA">{</span> <span class="w" id="mwUQ"> </span><span class="k" id="mwUg">for</span><span class="w" id="mwUw"> </span><span class="p" id="mwVA">(</span><span class="kt" id="mwVQ">int</span><span class="w" id="mwVg"> </span><span class="n" id="mwVw">k</span><span class="w" id="mwWA"> </span><span class="o" id="mwWQ">=</span><span class="w" id="mwWg"> </span><span class="n" id="mwWw">begin</span><span class="p" id="mwXA">;</span><span class="w" id="mwXQ"> </span><span class="n" id="mwXg">k</span><span class="w" id="mwXw"> </span><span class="o" id="mwYA"><</span><span class="w" id="mwYQ"> </span><span class="n" id="mwYg">end</span><span class="p" id="mwYw">;</span><span class="w" id="mwZA"> </span><span class="o" id="mwZQ">++</span><span class="n" id="mwZg">k</span><span class="p" id="mwZw">)</span><span class="w" id="mwaA"> </span><span class="p" id="mwaQ">{</span> <span class="w" id="mwag"> </span><span class="n" id="mwaw">b</span><span class="o" id="mwbA">[</span><span class="n" id="mwbQ">k</span><span class="o" id="mwbg">]</span><span class="w" id="mwbw"> </span><span class="o" id="mwcA">=</span><span class="w" id="mwcQ"> </span><span class="n" id="mwcg">a</span><span class="o" id="mwcw">[</span><span class="n" id="mwdA">k</span><span class="o" id="mwdQ">]</span><span class="p" id="mwdg">;</span> <span class="w" id="mwdw"> </span><span class="p" id="mweA">}</span> <span class="p" id="mweQ">}</span> <span class="c1" id="mweg">// Merge two sorted halves (from a) into a single sorted run (into b)</span> <span class="kt" id="mwew">void</span><span class="w" id="mwfA"> </span><span class="nf" id="mwfQ">topDownMerge</span><span class="p" id="mwfg">(</span><span class="kt" id="mwfw">int</span><span class="o" id="mwgA">[]</span><span class="w" id="mwgQ"> </span><span class="n" id="mwgg">a</span><span class="p" id="mwgw">,</span><span class="w" id="mwhA"> </span><span class="kt" id="mwhQ">int</span><span class="w" id="mwhg"> </span><span class="n" id="mwhw">begin</span><span class="p" id="mwiA">,</span><span class="w" id="mwiQ"> </span><span class="kt" id="mwig">int</span><span class="w" id="mwiw"> </span><span class="n" id="mwjA">middle</span><span class="p" id="mwjQ">,</span><span class="w" id="mwjg"> </span><span class="kt" id="mwjw">int</span><span class="w" id="mwkA"> </span><span class="n" id="mwkQ">end</span><span class="p" id="mwkg">,</span><span class="w" id="mwkw"> </span><span class="kt" id="mwlA">int</span><span class="o" id="mwlQ">[]</span><span class="w" id="mwlg"> </span><span class="n" id="mwlw">b</span><span class="p" id="mwmA">)</span><span class="w" id="mwmQ"> </span><span class="p" id="mwmg">{</span> <span class="w" id="mwmw"> </span><span class="kt" id="mwnA">int</span><span class="w" id="mwnQ"> </span><span class="n" id="mwng">i</span><span class="w" id="mwnw"> </span><span class="o" id="mwoA">=</span><span class="w" id="mwoQ"> </span><span class="n" id="mwog">begin</span><span class="p" id="mwow">;</span> <span class="w" id="mwpA"> </span><span class="kt" id="mwpQ">int</span><span class="w" id="mwpg"> </span><span class="n" id="mwpw">j</span><span class="w" id="mwqA"> </span><span class="o" id="mwqQ">=</span><span class="w" id="mwqg"> </span><span class="n" id="mwqw">middle</span><span class="p" id="mwrA">;</span> <span class="w" id="mwrQ"> </span><span class="c1" id="mwrg">// Merge the two sorted runs into b</span> <span class="w" id="mwrw"> </span><span class="k" id="mwsA">for</span><span class="w" id="mwsQ"> </span><span class="p" id="mwsg">(</span><span class="kt" id="mwsw">int</span><span class="w" id="mwtA"> </span><span class="n" id="mwtQ">k</span><span class="w" id="mwtg"> </span><span class="o" id="mwtw">=</span><span class="w" id="mwuA"> </span><span class="n" id="mwuQ">begin</span><span class="p" id="mwug">;</span><span class="w" id="mwuw"> </span><span class="n" id="mwvA">k</span><span class="w" id="mwvQ"> </span><span class="o" id="mwvg"><</span><span class="w" id="mwvw"> </span><span class="n" id="mwwA">end</span><span class="p" id="mwwQ">;</span><span class="w" id="mwwg"> </span><span class="o" id="mwww">++</span><span class="n" id="mwxA">k</span><span class="p" id="mwxQ">)</span><span class="w" id="mwxg"> </span><span class="p" id="mwxw">{</span> <span class="w" id="mwyA"> </span><span class="k" id="mwyQ">if</span><span class="w" id="mwyg"> </span><span class="p" id="mwyw">(</span><span class="n" id="mwzA">i</span><span class="w" id="mwzQ"> </span><span class="o" id="mwzg"><</span><span class="w" id="mwzw"> </span><span class="n" id="mw0A">middle</span><span class="w" id="mw0Q"> </span><span class="o" id="mw0g">&&</span><span class="w" id="mw0w"> </span><span class="p" id="mw1A">(</span><span class="n" id="mw1Q">j</span><span class="w" id="mw1g"> </span><span class="o" id="mw1w">>=</span><span class="w" id="mw2A"> </span><span class="n" id="mw2Q">end</span><span class="w" id="mw2g"> </span><span class="o" id="mw2w">||</span><span class="w" id="mw3A"> </span><span class="n" id="mw3Q">a</span><span class="o" id="mw3g">[</span><span class="n" id="mw3w">i</span><span class="o" id="mw4A">]</span><span class="w" id="mw4Q"> </span><span class="o" id="mw4g"><=</span><span class="w" id="mw4w"> </span><span class="n" id="mw5A">a</span><span class="o" id="mw5Q">[</span><span class="n" id="mw5g">j</span><span class="o" id="mw5w">]</span><span class="p" id="mw6A">))</span><span class="w" id="mw6Q"> </span><span class="p" id="mw6g">{</span> <span class="w" id="mw6w"> </span><span class="n" id="mw7A">b</span><span class="o" id="mw7Q">[</span><span class="n" id="mw7g">k</span><span class="o" id="mw7w">]</span><span class="w" id="mw8A"> </span><span class="o" id="mw8Q">=</span><span class="w" id="mw8g"> </span><span class="n" id="mw8w">a</span><span class="o" id="mw9A">[</span><span class="n" id="mw9Q">i</span><span class="o" id="mw9g">]</span><span class="p" id="mw9w">;</span><span class="w" id="mw-A"> </span><span class="c1" id="mw-Q">// Take element from the left run</span> <span class="w" id="mw-g"> </span><span class="n" id="mw-w">i</span><span class="o" id="mw_A">++</span><span class="p" id="mw_Q">;</span> <span class="w" id="mw_g"> </span><span class="p" id="mw_w">}</span><span class="w" id="mwAQA"> </span><span class="k" id="mwAQE">else</span><span class="w" id="mwAQI"> </span><span class="p" id="mwAQM">{</span> <span class="w" id="mwAQQ"> </span><span class="n" id="mwAQU">b</span><span class="o" id="mwAQY">[</span><span class="n" id="mwAQc">k</span><span class="o" id="mwAQg">]</span><span class="w" id="mwAQk"> </span><span class="o" id="mwAQo">=</span><span class="w" id="mwAQs"> </span><span class="n" id="mwAQw">a</span><span class="o" id="mwAQ0">[</span><span class="n" id="mwAQ4">j</span><span class="o" id="mwAQ8">]</span><span class="p" id="mwARA">;</span><span class="w" id="mwARE"> </span><span class="c1" id="mwARI">// Take element from the right run</span> <span class="w" id="mwARM"> </span><span class="n" id="mwARQ">j</span><span class="o" id="mwARU">++</span><span class="p" id="mwARY">;</span> <span class="w" id="mwARc"> </span><span class="p" id="mwARg">}</span> <span class="w" id="mwARk"> </span><span class="p" id="mwARo">}</span> <span class="p" id="mwARs">}</span> <span class="c1" id="mwARw">// Split the array a into two halves, sort both halves into b,</span> <span class="c1" id="mwAR0">// and merge the sorted halves back into a</span> <span class="kt" id="mwAR4">void</span><span class="w" id="mwAR8"> </span><span class="nf" id="mwASA">topDownSplitMerge</span><span class="p" id="mwASE">(</span><span class="kt" id="mwASI">int</span><span class="o" id="mwASM">[]</span><span class="w" id="mwASQ"> </span><span class="n" id="mwASU">a</span><span class="p" id="mwASY">,</span><span class="w" id="mwASc"> </span><span class="kt" id="mwASg">int</span><span class="w" id="mwASk"> </span><span class="n" id="mwASo">begin</span><span class="p" id="mwASs">,</span><span class="w" id="mwASw"> </span><span class="kt" id="mwAS0">int</span><span class="w" id="mwAS4"> </span><span class="n" id="mwAS8">end</span><span class="p" id="mwATA">,</span><span class="w" id="mwATE"> </span><span class="kt" id="mwATI">int</span><span class="o" id="mwATM">[]</span><span class="w" id="mwATQ"> </span><span class="n" id="mwATU">b</span><span class="p" id="mwATY">)</span><span class="w" id="mwATc"> </span><span class="p" id="mwATg">{</span> <span class="w" id="mwATk"> </span><span class="k" id="mwATo">if</span><span class="w" id="mwATs"> </span><span class="p" id="mwATw">(</span><span class="n" id="mwAT0">end</span><span class="w" id="mwAT4"> </span><span class="o" id="mwAT8">-</span><span class="w" id="mwAUA"> </span><span class="n" id="mwAUE">begin</span><span class="w" id="mwAUI"> </span><span class="o" id="mwAUM"><=</span><span class="w" id="mwAUQ"> </span><span class="mi" id="mwAUU">1</span><span class="p" id="mwAUY">)</span><span class="w" id="mwAUc"> </span><span class="p" id="mwAUg">{</span> <span class="w" id="mwAUk"> </span><span class="k" id="mwAUo">return</span><span class="p" id="mwAUs">;</span><span class="w" id="mwAUw"> </span><span class="c1" id="mwAU0">// Base case: Run size is 1, so it's already sorted</span> <span class="w" id="mwAU4"> </span><span class="p" id="mwAU8">}</span> <span class="w" id="mwAVA"> </span><span class="kt" id="mwAVE">int</span><span class="w" id="mwAVI"> </span><span class="n" id="mwAVM">middle</span><span class="w" id="mwAVQ"> </span><span class="o" id="mwAVU">=</span><span class="w" id="mwAVY"> </span><span class="p" id="mwAVc">(</span><span class="n" id="mwAVg">begin</span><span class="w" id="mwAVk"> </span><span class="o" id="mwAVo">+</span><span class="w" id="mwAVs"> </span><span class="n" id="mwAVw">end</span><span class="p" id="mwAV0">)</span><span class="w" id="mwAV4"> </span><span class="o" id="mwAV8">/</span><span class="w" id="mwAWA"> </span><span class="mi" id="mwAWE">2</span><span class="p" id="mwAWI">;</span><span class="w" id="mwAWM"> </span><span class="c1" id="mwAWQ">// Find the midpoint to split the array</span> <span class="w" id="mwAWU"> </span><span class="c1" id="mwAWY">// Recursively sort the left and right halves into b</span> <span class="w" id="mwAWc"> </span><span class="n" id="mwAWg">topDownSplitMerge</span><span class="p" id="mwAWk">(</span><span class="n" id="mwAWo">b</span><span class="p" id="mwAWs">,</span><span class="w" id="mwAWw"> </span><span class="n" id="mwAW0">begin</span><span class="p" id="mwAW4">,</span><span class="w" id="mwAW8"> </span><span class="n" id="mwAXA">middle</span><span class="p" id="mwAXE">,</span><span class="w" id="mwAXI"> </span><span class="n" id="mwAXM">a</span><span class="p" id="mwAXQ">);</span> <span class="w" id="mwAXU"> </span><span class="n" id="mwAXY">topDownSplitMerge</span><span class="p" id="mwAXc">(</span><span class="n" id="mwAXg">b</span><span class="p" id="mwAXk">,</span><span class="w" id="mwAXo"> </span><span class="n" id="mwAXs">middle</span><span class="p" id="mwAXw">,</span><span class="w" id="mwAX0"> </span><span class="n" id="mwAX4">end</span><span class="p" id="mwAX8">,</span><span class="w" id="mwAYA"> </span><span class="n" id="mwAYE">a</span><span class="p" id="mwAYI">);</span> <span class="w" id="mwAYM"> </span><span class="c1" id="mwAYQ">// Merge the sorted halves back into a</span> <span class="w" id="mwAYU"> </span><span class="n" id="mwAYY">topDownMerge</span><span class="p" id="mwAYc">(</span><span class="n" id="mwAYg">b</span><span class="p" id="mwAYk">,</span><span class="w" id="mwAYo"> </span><span class="n" id="mwAYs">begin</span><span class="p" id="mwAYw">,</span><span class="w" id="mwAY0"> </span><span class="n" id="mwAY4">middle</span><span class="p" id="mwAY8">,</span><span class="w" id="mwAZA"> </span><span class="n" id="mwAZE">end</span><span class="p" id="mwAZI">,</span><span class="w" id="mwAZM"> </span><span class="n" id="mwAZQ">a</span><span class="p" id="mwAZU">);</span> <span class="p" id="mwAZY">}</span> <span class="kt" id="mwAZc">void</span><span class="w" id="mwAZg"> </span><span class="nf" id="mwAZk">topDownMergeSort</span><span class="p" id="mwAZo">(</span><span class="kt" id="mwAZs">int</span><span class="o" id="mwAZw">[]</span><span class="w" id="mwAZ0"> </span><span class="n" id="mwAZ4">a</span><span class="p" id="mwAZ8">,</span><span class="w" id="mwAaA"> </span><span class="kt" id="mwAaE">int</span><span class="o" id="mwAaI">[]</span><span class="w" id="mwAaM"> </span><span class="n" id="mwAaQ">b</span><span class="p" id="mwAaU">,</span><span class="w" id="mwAaY"> </span><span class="kt" id="mwAac">int</span><span class="w" id="mwAag"> </span><span class="n" id="mwAak">n</span><span class="p" id="mwAao">)</span><span class="w" id="mwAas"> </span><span class="p" id="mwAaw">{</span> <span class="w" id="mwAa0"> </span><span class="c1" id="mwAa4">// Copy the entire array a into b initially</span> <span class="w" id="mwAa8"> </span><span class="n" id="mwAbA">copyArray</span><span class="p" id="mwAbE">(</span><span class="n" id="mwAbI">a</span><span class="p" id="mwAbM">,</span><span class="w" id="mwAbQ"> </span><span class="mi" id="mwAbU">0</span><span class="p" id="mwAbY">,</span><span class="w" id="mwAbc"> </span><span class="n" id="mwAbg">n</span><span class="p" id="mwAbk">,</span><span class="w" id="mwAbo"> </span><span class="n" id="mwAbs">b</span><span class="p" id="mwAbw">);</span> <span class="w" id="mwAb0"> </span><span class="c1" id="mwAb4">// Recursively split and merge the array b into a</span> <span class="w" id="mwAb8"> </span><span class="n" id="mwAcA">topDownSplitMerge</span><span class="p" id="mwAcE">(</span><span class="n" id="mwAcI">a</span><span class="p" id="mwAcM">,</span><span class="w" id="mwAcQ"> </span><span class="mi" id="mwAcU">0</span><span class="p" id="mwAcY">,</span><span class="w" id="mwAcc"> </span><span class="n" id="mwAcg">n</span><span class="p" id="mwAck">,</span><span class="w" id="mwAco"> </span><span class="n" id="mwAcs">b</span><span class="p" id="mwAcw">);</span> <span class="p" id="mwAc0">}</span>Sorting the entire array is accomplished by topDownMergeSort(a, b, a.length).
Bottom-up implementation
Example C-like code 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:
<span id="mwAdc"></span><span class="c1" id="mwAdg">// Copy array b into array a</span> <span class="kt" id="mwAdk">void</span><span class="w" id="mwAdo"> </span><span class="nf" id="mwAds">copyArray</span><span class="p" id="mwAdw">(</span><span class="kt" id="mwAd0">int</span><span class="o" id="mwAd4">[]</span><span class="w" id="mwAd8"> </span><span class="n" id="mwAeA">b</span><span class="p" id="mwAeE">,</span><span class="w" id="mwAeI"> </span><span class="kt" id="mwAeM">int</span><span class="o" id="mwAeQ">[]</span><span class="w" id="mwAeU"> </span><span class="n" id="mwAeY">a</span><span class="p" id="mwAec">,</span><span class="w" id="mwAeg"> </span><span class="kt" id="mwAek">int</span><span class="w" id="mwAeo"> </span><span class="n" id="mwAes">n</span><span class="p" id="mwAew">)</span><span class="w" id="mwAe0"> </span><span class="p" id="mwAe4">{</span> <span class="w" id="mwAe8"> </span><span class="k" id="mwAfA">for</span><span class="w" id="mwAfE"> </span><span class="p" id="mwAfI">(</span><span class="kt" id="mwAfM">int</span><span class="w" id="mwAfQ"> </span><span class="n" id="mwAfU">i</span><span class="w" id="mwAfY"> </span><span class="o" id="mwAfc">=</span><span class="w" id="mwAfg"> </span><span class="mi" id="mwAfk">0</span><span class="p" id="mwAfo">;</span><span class="w" id="mwAfs"> </span><span class="n" id="mwAfw">i</span><span class="w" id="mwAf0"> </span><span class="o" id="mwAf4"><</span><span class="w" id="mwAf8"> </span><span class="n" id="mwAgA">n</span><span class="p" id="mwAgE">;</span><span class="w" id="mwAgI"> </span><span class="n" id="mwAgM">i</span><span class="o" id="mwAgQ">++</span><span class="p" id="mwAgU">)</span><span class="w" id="mwAgY"> </span><span class="p" id="mwAgc">{</span> <span class="w" id="mwAgg"> </span><span class="n" id="mwAgk">a</span><span class="o" id="mwAgo">[</span><span class="n" id="mwAgs">i</span><span class="o" id="mwAgw">]</span><span class="w" id="mwAg0"> </span><span class="o" id="mwAg4">=</span><span class="w" id="mwAg8"> </span><span class="n" id="mwAhA">b</span><span class="o" id="mwAhE">[</span><span class="n" id="mwAhI">i</span><span class="o" id="mwAhM">]</span><span class="p" id="mwAhQ">;</span> <span class="w" id="mwAhU"> </span><span class="p" id="mwAhY">}</span> <span class="p" id="mwAhc">}</span> <span class="c1" id="mwAhg">// Left run is a[left : right-1].</span> <span class="c1" id="mwAhk">// Right run is a[right : end-1].</span> <span class="kt" id="mwAho">void</span><span class="w" id="mwAhs"> </span><span class="nf" id="mwAhw">bottomUpMerge</span><span class="p" id="mwAh0">(</span><span class="kt" id="mwAh4">int</span><span class="o" id="mwAh8">[]</span><span class="w" id="mwAiA"> </span><span class="n" id="mwAiE">a</span><span class="p" id="mwAiI">,</span><span class="w" id="mwAiM"> </span><span class="kt" id="mwAiQ">int</span><span class="w" id="mwAiU"> </span><span class="n" id="mwAiY">left</span><span class="p" id="mwAic">,</span><span class="w" id="mwAig"> </span><span class="kt" id="mwAik">int</span><span class="w" id="mwAio"> </span><span class="n" id="mwAis">right</span><span class="p" id="mwAiw">,</span><span class="w" id="mwAi0"> </span><span class="kt" id="mwAi4">int</span><span class="w" id="mwAi8"> </span><span class="n" id="mwAjA">end</span><span class="p" id="mwAjE">,</span><span class="w" id="mwAjI"> </span><span class="kt" id="mwAjM">int</span><span class="o" id="mwAjQ">[]</span><span class="w" id="mwAjU"> </span><span class="n" id="mwAjY">b</span><span class="p" id="mwAjc">)</span><span class="w" id="mwAjg"> </span><span class="p" id="mwAjk">{</span> <span class="w" id="mwAjo"> </span><span class="kt" id="mwAjs">int</span><span class="w" id="mwAjw"> </span><span class="n" id="mwAj0">i</span><span class="w" id="mwAj4"> </span><span class="o" id="mwAj8">=</span><span class="w" id="mwAkA"> </span><span class="n" id="mwAkE">left</span><span class="p" id="mwAkI">;</span> <span class="w" id="mwAkM"> </span><span class="kt" id="mwAkQ">int</span><span class="w" id="mwAkU"> </span><span class="n" id="mwAkY">j</span><span class="w" id="mwAkc"> </span><span class="o" id="mwAkg">=</span><span class="w" id="mwAkk"> </span><span class="n" id="mwAko">right</span><span class="p" id="mwAks">;</span> <span class="w" id="mwAkw"> </span><span class="c1" id="mwAk0">// While there are elements in the left or right runs...</span> <span class="w" id="mwAk4"> </span><span class="k" id="mwAk8">for</span><span class="w" id="mwAlA"> </span><span class="p" id="mwAlE">(</span><span class="kt" id="mwAlI">int</span><span class="w" id="mwAlM"> </span><span class="n" id="mwAlQ">k</span><span class="w" id="mwAlU"> </span><span class="o" id="mwAlY">=</span><span class="w" id="mwAlc"> </span><span class="n" id="mwAlg">left</span><span class="p" id="mwAlk">;</span><span class="w" id="mwAlo"> </span><span class="n" id="mwAls">k</span><span class="w" id="mwAlw"> </span><span class="o" id="mwAl0"><</span><span class="w" id="mwAl4"> </span><span class="n" id="mwAl8">end</span><span class="p" id="mwAmA">;</span><span class="w" id="mwAmE"> </span><span class="o" id="mwAmI">++</span><span class="n" id="mwAmM">k</span><span class="p" id="mwAmQ">)</span><span class="w" id="mwAmU"> </span><span class="p" id="mwAmY">{</span> <span class="w" id="mwAmc"> </span><span class="c1" id="mwAmg">// If left run head exists and is <= existing right run head.</span> <span class="w" id="mwAmk"> </span><span class="k" id="mwAmo">if</span><span class="w" id="mwAms"> </span><span class="p" id="mwAmw">(</span><span class="n" id="mwAm0">i</span><span class="w" id="mwAm4"> </span><span class="o" id="mwAm8"><</span><span class="w" id="mwAnA"> </span><span class="n" id="mwAnE">right</span><span class="w" id="mwAnI"> </span><span class="o" id="mwAnM">&&</span><span class="w" id="mwAnQ"> </span><span class="p" id="mwAnU">(</span><span class="n" id="mwAnY">j</span><span class="w" id="mwAnc"> </span><span class="o" id="mwAng">>=</span><span class="w" id="mwAnk"> </span><span class="n" id="mwAno">end</span><span class="w" id="mwAns"> </span><span class="o" id="mwAnw">||</span><span class="w" id="mwAn0"> </span><span class="n" id="mwAn4">a</span><span class="o" id="mwAn8">[</span><span class="n" id="mwAoA">i</span><span class="o" id="mwAoE">]</span><span class="w" id="mwAoI"> </span><span class="o" id="mwAoM"><=</span><span class="w" id="mwAoQ"> </span><span class="n" id="mwAoU">a</span><span class="o" id="mwAoY">[</span><span class="n" id="mwAoc">j</span><span class="o" id="mwAog">]</span><span class="p" id="mwAok">))</span><span class="w" id="mwAoo"> </span><span class="p" id="mwAos">{</span> <span class="w" id="mwAow"> </span><span class="n" id="mwAo0">b</span><span class="o" id="mwAo4">[</span><span class="n" id="mwAo8">k</span><span class="o" id="mwApA">]</span><span class="w" id="mwApE"> </span><span class="o" id="mwApI">=</span><span class="w" id="mwApM"> </span><span class="n" id="mwApQ">a</span><span class="o" id="mwApU">[</span><span class="n" id="mwApY">i</span><span class="o" id="mwApc">]</span><span class="p" id="mwApg">;</span> <span class="w" id="mwApk"> </span><span class="n" id="mwApo">i</span><span class="w" id="mwAps"> </span><span class="o" id="mwApw">=</span><span class="w" id="mwAp0"> </span><span class="n" id="mwAp4">i</span><span class="w" id="mwAp8"> </span><span class="o" id="mwAqA">+</span><span class="w" id="mwAqE"> </span><span class="mi" id="mwAqI">1</span><span class="p" id="mwAqM">;</span> <span class="w" id="mwAqQ"> </span><span class="p" id="mwAqU">}</span><span class="w" id="mwAqY"> </span><span class="k" id="mwAqc">else</span><span class="w" id="mwAqg"> </span><span class="p" id="mwAqk">{</span> <span class="w" id="mwAqo"> </span><span class="n" id="mwAqs">b</span><span class="o" id="mwAqw">[</span><span class="n" id="mwAq0">k</span><span class="o" id="mwAq4">]</span><span class="w" id="mwAq8"> </span><span class="o" id="mwArA">=</span><span class="w" id="mwArE"> </span><span class="n" id="mwArI">a</span><span class="o" id="mwArM">[</span><span class="n" id="mwArQ">j</span><span class="o" id="mwArU">]</span><span class="p" id="mwArY">;</span> <span class="w" id="mwArc"> </span><span class="n" id="mwArg">j</span><span class="w" id="mwArk"> </span><span class="o" id="mwAro">=</span><span class="w" id="mwArs"> </span><span class="n" id="mwArw">j</span><span class="w" id="mwAr0"> </span><span class="o" id="mwAr4">+</span><span class="w" id="mwAr8"> </span><span class="mi" id="mwAsA">1</span><span class="p" id="mwAsE">;</span><span class="w" id="mwAsI"> </span> <span class="w" id="mwAsM"> </span><span class="p" id="mwAsQ">}</span> <span class="w" id="mwAsU"> </span><span class="p" id="mwAsY">}</span> <span class="p" id="mwAsc">}</span> <span class="kt" id="mwAsg">void</span><span class="w" id="mwAsk"> </span><span class="nf" id="mwAso">bottomUpMergeSort</span><span class="p" id="mwAss">(</span><span class="kt" id="mwAsw">int</span><span class="o" id="mwAs0">[]</span><span class="w" id="mwAs4"> </span><span class="n" id="mwAs8">a</span><span class="p" id="mwAtA">,</span><span class="w" id="mwAtE"> </span><span class="kt" id="mwAtI">int</span><span class="o" id="mwAtM">[]</span><span class="w" id="mwAtQ"> </span><span class="n" id="mwAtU">b</span><span class="p" id="mwAtY">,</span><span class="w" id="mwAtc"> </span><span class="kt" id="mwAtg">int</span><span class="w" id="mwAtk"> </span><span class="n" id="mwAto">n</span><span class="p" id="mwAts">)</span><span class="w" id="mwAtw"> </span><span class="p" id="mwAt0">{</span> <span class="w" id="mwAt4"> </span><span class="c1" id="mwAt8">// Each 1-element run in a is already "sorted".</span> <span class="w" id="mwAuA"> </span><span class="c1" id="mwAuE">// Make successively longer sorted runs of length 2, 4, 8, 16... until the whole array is sorted.</span> <span class="w" id="mwAuI"> </span><span class="k" id="mwAuM">for</span><span class="w" id="mwAuQ"> </span><span class="p" id="mwAuU">(</span><span class="kt" id="mwAuY">int</span><span class="w" id="mwAuc"> </span><span class="n" id="mwAug">width</span><span class="w" id="mwAuk"> </span><span class="o" id="mwAuo">=</span><span class="w" id="mwAus"> </span><span class="mi" id="mwAuw">1</span><span class="p" id="mwAu0">;</span><span class="w" id="mwAu4"> </span><span class="n" id="mwAu8">width</span><span class="w" id="mwAvA"> </span><span class="o" id="mwAvE"><</span><span class="w" id="mwAvI"> </span><span class="n" id="mwAvM">n</span><span class="p" id="mwAvQ">;</span><span class="w" id="mwAvU"> </span><span class="n" id="mwAvY">width</span><span class="w" id="mwAvc"> </span><span class="o" id="mwAvg">*=</span><span class="w" id="mwAvk"> </span><span class="mi" id="mwAvo">2</span><span class="p" id="mwAvs">)</span><span class="w" id="mwAvw"> </span><span class="p" id="mwAv0">{</span> <span class="w" id="mwAv4"> </span><span class="c1" id="mwAv8">// Array a is full of runs of length width.</span> <span class="w" id="mwAwA"> </span><span class="k" id="mwAwE">for</span><span class="w" id="mwAwI"> </span><span class="p" id="mwAwM">(</span><span class="kt" id="mwAwQ">int</span><span class="w" id="mwAwU"> </span><span class="n" id="mwAwY">i</span><span class="w" id="mwAwc"> </span><span class="o" id="mwAwg">=</span><span class="w" id="mwAwk"> </span><span class="mi" id="mwAwo">0</span><span class="p" id="mwAws">;</span><span class="w" id="mwAww"> </span><span class="n" id="mwAw0">i</span><span class="w" id="mwAw4"> </span><span class="o" id="mwAw8"><</span><span class="w" id="mwAxA"> </span><span class="n" id="mwAxE">n</span><span class="p" id="mwAxI">;</span><span class="w" id="mwAxM"> </span><span class="n" id="mwAxQ">i</span><span class="w" id="mwAxU"> </span><span class="o" id="mwAxY">=</span><span class="w" id="mwAxc"> </span><span class="n" id="mwAxg">i</span><span class="w" id="mwAxk"> </span><span class="o" id="mwAxo">+</span><span class="w" id="mwAxs"> </span><span class="mi" id="mwAxw">2</span><span class="w" id="mwAx0"> </span><span class="o" id="mwAx4">*</span><span class="w" id="mwAx8"> </span><span class="n" id="mwAyA">width</span><span class="p" id="mwAyE">)</span><span class="w" id="mwAyI"> </span><span class="p" id="mwAyM">{</span> <span class="w" id="mwAyQ"> </span><span class="c1" id="mwAyU">// Merge two runs: a[i:i+width-1] and a[i+width:i+2*width-1] to b[]</span> <span class="w" id="mwAyY"> </span><span class="c1" id="mwAyc">// or copy a[i:n-1] to b[] (if (i+width >= n))</span> <span class="w" id="mwAyg"> </span><span class="n" id="mwAyk">bottomUpMerge</span><span class="p" id="mwAyo">(</span><span class="n" id="mwAys">a</span><span class="p" id="mwAyw">,</span><span class="w" id="mwAy0"> </span><span class="n" id="mwAy4">i</span><span class="p" id="mwAy8">,</span><span class="w" id="mwAzA"> </span><span class="n" id="mwAzE">Math</span><span class="p" id="mwAzI">.</span><span class="na" id="mwAzM">min</span><span class="p" id="mwAzQ">(</span><span class="n" id="mwAzU">i</span><span class="w" id="mwAzY"> </span><span class="o" id="mwAzc">+</span><span class="w" id="mwAzg"> </span><span class="n" id="mwAzk">width</span><span class="p" id="mwAzo">,</span><span class="w" id="mwAzs"> </span><span class="n" id="mwAzw">n</span><span class="p" id="mwAz0">),</span><span class="w" id="mwAz4"> </span><span class="n" id="mwAz8">Math</span><span class="p" id="mwA0A">.</span><span class="na" id="mwA0E">min</span><span class="p" id="mwA0I">(</span><span class="n" id="mwA0M">i</span><span class="w" id="mwA0Q"> </span><span class="o" id="mwA0U">+</span><span class="w" id="mwA0Y"> </span><span class="mi" id="mwA0c">2</span><span class="w" id="mwA0g"> </span><span class="o" id="mwA0k">*</span><span class="w" id="mwA0o"> </span><span class="n" id="mwA0s">width</span><span class="p" id="mwA0w">,</span><span class="w" id="mwA00"> </span><span class="n" id="mwA04">n</span><span class="p" id="mwA08">),</span><span class="w" id="mwA1A"> </span><span class="n" id="mwA1E">b</span><span class="p" id="mwA1I">);</span> <span class="w" id="mwA1M"> </span><span class="p" id="mwA1Q">}</span> <span class="w" id="mwA1U"> </span><span class="c1" id="mwA1Y">// Now work array b is full of runs of length 2 * width.</span> <span class="w" id="mwA1c"> </span><span class="c1" id="mwA1g">// Copy array b to array a for the next iteration.</span> <span class="w" id="mwA1k"> </span><span class="c1" id="mwA1o">// A more efficient implementation would swap the roles of a and b.</span> <span class="w" id="mwA1s"> </span><span class="n" id="mwA1w">copyArray</span><span class="p" id="mwA10">(</span><span class="n" id="mwA14">b</span><span class="p" id="mwA18">,</span><span class="w" id="mwA2A"> </span><span class="n" id="mwA2E">a</span><span class="p" id="mwA2I">,</span><span class="w" id="mwA2M"> </span><span class="n" id="mwA2Q">n</span><span class="p" id="mwA2U">);</span> <span class="w" id="mwA2Y"> </span><span class="p" id="mwA2c">}</span> <span class="p" id="mwA2g">}</span>Top-down implementation using lists
Pseudocode for top-down merge sort algorithm which recursively divides the input list into smaller sublists until the sublists are trivially sorted, and then merges the sublists while returning up the call chain.
<b id="mwA20">function</b> merge_sort(<i id="mwA24">list</i> m) <b id="mwA28">is</b> // <i id="mwA3A">Base case. A list of zero or one elements is sorted, by definition.</i> <b id="mwA3E">if</b> length of m ≤ 1 <b id="mwA3I">then</b> <b id="mwA3M">return</b> m // <i id="mwA3Q">Recursive case. First, divide the list into equal-sized sublists</i> // <i id="mwA3U">consisting of the first half and second half of the list.</i> // <i id="mwA3Y">This assumes lists start at index 0.</i> <b id="mwA3c">var</b> left := empty list <b id="mwA3g">var</b> right := empty list <b id="mwA3k">for each</b> x <b id="mwA3o">with index</b> i <b id="mwA3s">in</b> m <b id="mwA3w">do</b> <b id="mwA30">if</b> i < (length of m)/2 <b id="mwA34">then</b> add x to left <b id="mwA38">else</b> add x to right // <i id="mwA4A">Recursively sort both sublists.</i> left := merge_sort(left) right := merge_sort(right) // Then merge the now-sorted sublists. <b id="mwA4E">return</b> merge(left, right)
In this example, the merge function merges the left and right sublists.
<b id="mwA4Y">function</b> merge(left, right) <b id="mwA4c">is</b> <b id="mwA4g">var</b> result := empty list <b id="mwA4k">while</b> left is not empty <b id="mwA4o">and</b> right is not empty <b id="mwA4s">do</b> <b id="mwA4w">if</b> first(left) ≤ first(right) <b id="mwA40">then</b> append first(left) to result left := rest(left) <b id="mwA44">else</b> append first(right) to result right := rest(right) // <i id="mwA48">Either left or right may have elements left; consume them.</i> // <i id="mwA5A">(Only one of the following loops will actually be entered.)</i> <b id="mwA5E">while</b> left is not empty <b id="mwA5I">do</b> append first(left) to result left := rest(left) <b id="mwA5M">while</b> right is not empty <b id="mwA5Q">do</b> append first(right) to result right := rest(right) <b id="mwA5U">return</b> result
Bottom-up implementation using lists
Pseudocode for bottom-up merge sort algorithm which uses a small fixed size array of references to nodes, where array[i] is either a reference to a list of size 2i or nil. node is a reference or pointer to a node. The merge() function would be similar to the one shown in the top-down merge lists example, it merges two already sorted lists, and handles empty lists. In this case, merge() would use node for its input parameters and return value.
<b id="mwA6M">function</b> merge_sort(<i id="mwA6Q">node</i> head) <b id="mwA6U">is</b> // return if empty list <b id="mwA6Y">if</b> head = nil <b id="mwA6c">then</b> <b id="mwA6g">return</b> nil <b id="mwA6k">var</b> <i id="mwA6o">node</i> array[32]; initially all nil <b id="mwA6s">var</b> <i id="mwA6w">node</i> result <b id="mwA60">var</b> <i id="mwA64">node</i> next <b id="mwA68">var</b> <i id="mwA7A">int</i> i result := head // merge nodes into array <b id="mwA7E">while</b> result ≠ nil <b id="mwA7I">do</b> next := result.next; result.next := nil <b id="mwA7M">for</b> (i = 0; (i < 32) && (array[i] ≠ nil); i += 1) <b id="mwA7Q">do</b> result := merge(array[i], result) array[i] := nil // do not go past end of array <b id="mwA7U">if</b> i = 32 <b id="mwA7Y">then</b> i -= 1 array[i] := result result := next // merge array into single list result := nil <b id="mwA7c">for</b> (i = 0; i < 32; i += 1) <b id="mwA7g">do</b> result := merge(array[i], result) <b id="mwA7k">return</b> result
Top-down implementation in a declarative style
Haskell-like pseudocode, showing how merge sort can be implemented in such a language using constructs and ideas from functional programming.
<span id="mwA8A"></span><span class="nf" id="mwA8E">mergeSort</span><span class="w" id="mwA8I"> </span><span class="ow" id="mwA8M">::</span><span class="w" id="mwA8Q"> </span><span class="kt" id="mwA8U">Ord</span><span class="w" id="mwA8Y"> </span><span class="n" id="mwA8c">a</span><span class="w" id="mwA8g"> </span><span class="ow" id="mwA8k">=></span><span class="w" id="mwA8o"> </span><span class="p" id="mwA8s">[</span><span class="n" id="mwA8w">a</span><span class="p" id="mwA80">]</span><span class="w" id="mwA84"> </span><span class="ow" id="mwA88">-></span><span class="w" id="mwA9A"> </span><span class="p" id="mwA9E">[</span><span class="n" id="mwA9I">a</span><span class="p" id="mwA9M">]</span> <span class="nf" id="mwA9Q">mergeSort</span><span class="w" id="mwA9U"> </span><span class="kt" id="mwA9Y">[]</span><span class="w" id="mwA9c"> </span><span class="ow" id="mwA9g">=</span><span class="w" id="mwA9k"> </span><span class="kt" id="mwA9o">[]</span> <span class="nf" id="mwA9s">mergeSort</span><span class="w" id="mwA9w"> </span><span class="p" id="mwA90">[</span><span class="n" id="mwA94">x</span><span class="p" id="mwA98">]</span><span class="w" id="mwA-A"> </span><span class="ow" id="mwA-E">=</span><span class="w" id="mwA-I"> </span><span class="p" id="mwA-M">[</span><span class="n" id="mwA-Q">x</span><span class="p" id="mwA-U">]</span> <span class="nf" id="mwA-Y">mergeSort</span><span class="w" id="mwA-c"> </span><span class="n" id="mwA-g">xs</span><span class="w" id="mwA-k"> </span><span class="ow" id="mwA-o">=</span><span class="w" id="mwA-s"> </span><span class="n" id="mwA-w">merge</span><span class="w" id="mwA-0"> </span><span class="p" id="mwA-4">(</span><span class="n" id="mwA-8">mergeSort</span><span class="w" id="mwA_A"> </span><span class="n" id="mwA_E">l</span><span class="p" id="mwA_I">,</span><span class="w" id="mwA_M"> </span><span class="n" id="mwA_Q">mergeSort</span><span class="w" id="mwA_U"> </span><span class="n" id="mwA_Y">r</span><span class="p" id="mwA_c">)</span> <span class="w" id="mwA_g"> </span><span class="kr" id="mwA_k">where</span><span class="w" id="mwA_o"> </span><span class="p" id="mwA_s">(</span><span class="n" id="mwA_w">l</span><span class="p" id="mwA_0">,</span><span class="w" id="mwA_4"> </span><span class="n" id="mwA_8">r</span><span class="p" id="mwBAA">)</span><span class="w" id="mwBAE"> </span><span class="ow" id="mwBAI">=</span><span class="w" id="mwBAM"> </span><span class="n" id="mwBAQ">splitAt</span><span class="w" id="mwBAU"> </span><span class="p" id="mwBAY">(</span><span class="n" id="mwBAc">length</span><span class="w" id="mwBAg"> </span><span class="n" id="mwBAk">xs</span><span class="w" id="mwBAo"> </span><span class="p" id="mwBAs">`</span><span class="n" id="mwBAw">div</span><span class="p" id="mwBA0">`</span><span class="w" id="mwBA4"> </span><span class="mi" id="mwBA8">2</span><span class="p" id="mwBBA">)</span><span class="w" id="mwBBE"> </span><span class="n" id="mwBBI">xs</span> <span class="nf" id="mwBBM">merge</span><span class="w" id="mwBBQ"> </span><span class="ow" id="mwBBU">::</span><span class="w" id="mwBBY"> </span><span class="kt" id="mwBBc">Ord</span><span class="w" id="mwBBg"> </span><span class="n" id="mwBBk">a</span><span class="w" id="mwBBo"> </span><span class="ow" id="mwBBs">=></span><span class="w" id="mwBBw"> </span><span class="p" id="mwBB0">([</span><span class="n" id="mwBB4">a</span><span class="p" id="mwBB8">],</span><span class="w" id="mwBCA"> </span><span class="p" id="mwBCE">[</span><span class="n" id="mwBCI">a</span><span class="p" id="mwBCM">])</span><span class="w" id="mwBCQ"> </span><span class="ow" id="mwBCU">-></span><span class="w" id="mwBCY"> </span><span class="p" id="mwBCc">[</span><span class="n" id="mwBCg">a</span><span class="p" id="mwBCk">]</span> <span class="nf" id="mwBCo">merge</span><span class="w" id="mwBCs"> </span><span class="p" id="mwBCw">(</span><span class="kt" id="mwBC0">[]</span><span class="p" id="mwBC4">,</span><span class="w" id="mwBC8"> </span><span class="n" id="mwBDA">xs</span><span class="p" id="mwBDE">)</span><span class="w" id="mwBDI"> </span><span class="ow" id="mwBDM">=</span><span class="w" id="mwBDQ"> </span><span class="n" id="mwBDU">xs</span> <span class="nf" id="mwBDY">merge</span><span class="w" id="mwBDc"> </span><span class="p" id="mwBDg">(</span><span class="n" id="mwBDk">xs</span><span class="p" id="mwBDo">,</span><span class="w" id="mwBDs"> </span><span class="kt" id="mwBDw">[]</span><span class="p" id="mwBD0">)</span><span class="w" id="mwBD4"> </span><span class="ow" id="mwBD8">=</span><span class="w" id="mwBEA"> </span><span class="n" id="mwBEE">xs</span> <span class="nf" id="mwBEI">merge</span><span class="w" id="mwBEM"> </span><span class="p" id="mwBEQ">(</span><span class="n" id="mwBEU">x</span><span class="kt" id="mwBEY">:</span><span class="n" id="mwBEc">xs</span><span class="p" id="mwBEg">,</span><span class="w" id="mwBEk"> </span><span class="n" id="mwBEo">y</span><span class="kt" id="mwBEs">:</span><span class="n" id="mwBEw">ys</span><span class="p" id="mwBE0">)</span><span class="w" id="mwBE4"> </span><span class="o" id="mwBE8">|</span><span class="w" id="mwBFA"> </span><span class="n" id="mwBFE">x</span><span class="w" id="mwBFI"> </span><span class="o" id="mwBFM"><=</span><span class="w" id="mwBFQ"> </span><span class="n" id="mwBFU">y</span><span class="w" id="mwBFY"> </span><span class="ow" id="mwBFc">=</span><span class="w" id="mwBFg"> </span><span class="n" id="mwBFk">x</span><span class="w" id="mwBFo"> </span><span class="kt" id="mwBFs">:</span><span class="w" id="mwBFw"> </span><span class="n" id="mwBF0">merge</span><span class="p" id="mwBF4">(</span><span class="n" id="mwBF8">xs</span><span class="p" id="mwBGA">,</span><span class="w" id="mwBGE"> </span><span class="n" id="mwBGI">y</span><span class="kt" id="mwBGM">:</span><span class="n" id="mwBGQ">ys</span><span class="p" id="mwBGU">)</span> <span class="w" id="mwBGY"> </span><span class="o" id="mwBGc">|</span><span class="w" id="mwBGg"> </span><span class="n" id="mwBGk">otherwise</span><span class="w" id="mwBGo"> </span><span class="ow" id="mwBGs">=</span><span class="w" id="mwBGw"> </span><span class="n" id="mwBG0">y</span><span class="w" id="mwBG4"> </span><span class="kt" id="mwBG8">:</span><span class="w" id="mwBHA"> </span><span class="n" id="mwBHE">merge</span><span class="p" id="mwBHI">(</span><span class="n" id="mwBHM">x</span><span class="kt" id="mwBHQ">:</span><span class="n" id="mwBHU">xs</span><span class="p" id="mwBHY">,</span><span class="w" id="mwBHc"> </span><span class="n" id="mwBHg">ys</span><span class="p" id="mwBHk">)</span>
Sign in to keep reading
8 more chapters are free with a Lably account.
Analysis
In sorting n objects, merge sort has an average and worst-case performance of O(n log n) comparisons. If the running time (number of comparisons) of merge sort for a list of length n is T(n), then the recurrence relation T(n) = 2T(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 for divide-and-conquer recurrences.
The number of comparisons made by merge sort in the worst case is given by the sorting numbers. These numbers are equal to or slightly smaller than (n ⌈lg n⌉ − 2⌈lg n⌉ + 1), which is between (n lg n − n + 1) and (n lg n + n + O(lg n)). Merge sort's best case takes about half as many iterations as its worst case.
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
In the worst case, merge sort uses approximately 39% fewer comparisons than quicksort does in its average case, and in terms of moves, merge sort's worst case complexity is O(n log n) - the same complexity as quicksort's best case.
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, where sequentially accessed data structures are very common. Unlike some (efficient) implementations of quicksort, merge sort is a stable sort.
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 variations that need only n/2 extra spaces).
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. Both monotonic and bitonic (alternating up/down) runs may be exploited, with lists (or equivalently tapes or files) being convenient data structures (used as FIFO queues or LIFO stacks). 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. In many practical cases, long natural runs are present, and for that reason natural merge sort is exploited as the key component of Timsort. 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)
Formally, the natural merge sort is said to be Runs-optimal, where is the number of runs in , minus one.
Tournament replacement selection sorts are used to gather the initial runs for external sorting algorithms.
Ping-pong merge sort
Instead of merging two blocks at a time, a ping-pong merge merges four blocks at a time. The four sorted blocks are merged simultaneously to auxiliary space into two sorted blocks, then the two sorted blocks are merged back to main memory. Doing so omits the copy operation and reduces the total number of moves by half. An early public domain implementation of a four-at-once merge was by WikiSort in 2014, the method was later that year described as an optimization for patience sorting and named a ping-pong merge. Quadsort implemented the method in 2020 and named it a quad merge.
In-place merge sort
One drawback of merge sort, when implemented on arrays, is its O(n) working memory requirement. Several methods to reduce memory or make merge sort fully in-place have been suggested:
- Kronrod (1969) suggested an alternative version of merge sort that uses constant additional space.
- Katajainen et al. present an algorithm that requires a constant amount of working memory: enough storage space to hold one element of the input array, and additional space to hold O(1) pointers into the input array. They achieve an O(n log n) time bound with small constants, but their algorithm is not stable.
- Several attempts have been made at producing an in-place merge algorithm that can be combined with a standard (top-down or bottom-up) merge sort to produce an in-place merge sort. In this case, the notion of "in-place" can be relaxed to mean "taking logarithmic stack space", because standard merge sort requires that amount of space for its own stack usage. It was shown by Geffert et al. that in-place, stable merging is possible in O(n log n) time using a constant amount of scratch space, but their algorithm is complicated and has high constant factors: merging arrays of length n and m can take 5n + 12m + o(m) moves. This high constant factor and complicated in-place algorithm was made simpler and easier to understand. Bing-Chao Huang and Michael A. Langston presented a straightforward linear time algorithm practical in-place merge to merge a sorted list using fixed amount of additional space. They both have used the work of Kronrod and others. It merges in linear time and constant extra space. The algorithm takes little more average time than standard merge sort algorithms, free to exploit O(n) temporary extra memory cells, by less than a factor of two. Though the algorithm is much faster in a practical way, it is unstable for some lists. But using similar concepts, they have been able to solve this problem. Other in-place algorithms include SymMerge, which takes O((n + m) log (n + m)) time in total and is stable. Plugging such an algorithm into merge sort increases its complexity to the non-linearithmic, but still quasilinear, O(n (log n)2).
- Many applications of external sorting use a form of merge sorting where the input gets split up to a higher number of sublists, ideally to a number for which merging them still makes the currently processed set of pages fit into main memory.
- A modern stable, linear, and in-place merge variant is block merge sort, which creates a section of unique values to use as swap space.
- The space overhead can be reduced to O(√n) by using binary searches and rotations. This method is employed by the C++ STL library and quadsort.
- 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.
- A simple way to reduce 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.
Use with tape drives
An external merge sort is practical to run using disk or tape drives when the data to be sorted is too large to fit into 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 two 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 two record buffers, the algorithm is similar to the 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 nine 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. One of them, the Knuth's 'snowplow' (based on a binary min-heap), generates runs twice as long (on average) as a size of memory used.
With some overhead, the above algorithm can be modified to use three tapes. O(n log n) running time can also be achieved using two queues, or a stack and a queue, or three stacks. In the other direction, using k > two tapes (and O(k) items in memory), we can reduce the number of tape operations in O(log k) times by using a k/2-way merge.
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 hierarchies are used. 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 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. (LaMarca & Ladner 1997)
Parallel merge sort
Merge sort parallelizes well due to the use of the divide-and-conquer method. Several different parallel variants of the algorithm have been developed over the years. Some parallel merge sort algorithms are strongly related to the sequential top-down merge algorithm while others have a different general structure and use the K-way merge method.
Merge sort with parallel recursion
The sequential merge sort procedure can be described in two phases, the divide phase and the merge phase. The first consists of many recursive calls that repeatedly perform the same division process until the subsequences are trivially sorted (containing one or no element). An intuitive approach is the parallelization of those recursive calls. Following pseudocode describes the merge sort with parallel recursion using the fork and join keywords:
// <i id="mwBX0">Sort elements lo through hi (exclusive) of array A.</i> <b id="mwBX4">algorithm</b> mergesort(A, lo, hi) <b id="mwBX8">is</b> <b id="mwBYA">if</b> lo+1 < hi <b id="mwBYE">then</b> // <i id="mwBYI">Two or more elements.</i> mid := ⌊(lo + hi) / 2⌋ <b id="mwBYM">fork</b> mergesort(A, lo, mid) mergesort(A, mid, hi) <b id="mwBYQ">join</b> merge(A, lo, mid, hi)
This algorithm is the trivial modification of the sequential version and does not parallelize well. Therefore, its speedup is not very impressive. It has a span of , which is only an improvement of compared to the sequential version (see Introduction to Algorithms). This is mainly due to the sequential merge method, as it is the bottleneck of the parallel executions.
Merge sort with parallel merging
Better parallelism can be achieved by using a parallel merge algorithm. Cormen et al. present a binary variant that merges two sorted sub-sequences into one sorted output sequence.
In one of the sequences (the longer one if unequal length), the element of the middle index is selected. Its position in the other sequence is determined in such a way that this sequence would remain sorted if this element were inserted at this position. Thus, one knows how many other elements from both sequences are smaller and the position of the selected element in the output sequence can be calculated. For the partial sequences of the smaller and larger elements created in this way, the merge algorithm is again executed in parallel until the base case of the recursion is reached.
The following pseudocode shows the modified parallel merge sort method using the parallel merge algorithm (adopted from Cormen et al.).
/** * A: Input array * B: Output array * lo: lower bound * hi: upper bound * off: offset */ <b id="mwBZc">algorithm</b> parallelMergesort(A, lo, hi, B, off) <b id="mwBZg">is</b> len := hi - lo + 1 <b id="mwBZk">if</b> len == 1 <b id="mwBZo">then</b> <span typeof="mw:Nowiki" id="mwBZs"> B[off] := A[lo]</span> <b id="mwBZw">else</b> let T[1..len] be a new array mid := ⌊(lo + hi) / 2⌋ mid' := mid - lo + 1 <b id="mwBZ0">fork</b> parallelMergesort(A, lo, mid, T, 1) parallelMergesort(A, mid + 1, hi, T, mid' + 1) <b id="mwBZ4">join</b> parallelMerge(T, 1, mid', mid' + 1, len, B, off)
In order to analyze a recurrence relation for the worst case span, the recursive calls of parallelMergesort have to be incorporated only once due to their parallel execution, obtaining
For detailed information about the complexity of the parallel merge procedure, see Merge algorithm.
The solution of this recurrence is given by
This parallel merge algorithm reaches a parallelism of , which is much higher than the parallelism of the previous algorithm. Such a sort can perform 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.
Parallel multiway merge sort
It seems arbitrary to restrict the merge sort algorithms to a binary merge method, since there are usually p > 2 processors available. A better approach may be to use a K-way merge method, a generalization of binary merge, in which sorted sequences are merged. This merge variant is well suited to describe a sorting algorithm on a PRAM.
Basic idea
Given an unsorted sequence of elements, the goal is to sort the sequence with available processors. These elements are distributed equally among all processors and sorted locally using a sequential Sorting algorithm. Hence, the sequence consists of sorted sequences of length . For simplification let be a multiple of , so that for .
These sequences will be used to perform a multisequence selection/splitter selection. For , the algorithm determines splitter elements with global rank . Then the corresponding positions of in each sequence are determined with binary search and thus the are further partitioned into subsequences with .
Furthermore, the elements of are assigned to processor , means all elements between rank and rank , which are distributed over all . Thus, each processor receives a sequence of sorted sequences. The fact that the rank of the splitter elements was chosen globally, provides two important properties: On the one hand, was chosen so that each processor can still operate on elements after assignment. The algorithm is perfectly load-balanced. On the other hand, all elements on processor are less than or equal to all elements on processor . Hence, each processor performs the p-way merge locally and thus obtains a sorted sequence from its sub-sequences. Because of the second property, no further p-way-merge has to be performed, the results only have to be put together in the order of the processor number.
Multi-sequence selection
In its simplest form, given sorted sequences distributed evenly on processors and a rank , the task is to find an element with a global rank in the union of the sequences. Hence, this can be used to divide each in two parts at a splitter index , where the lower part contains only elements which are smaller than , while the elements bigger than are located in the upper part.
The presented sequential algorithm returns the indices of the splits in each sequence, e.g. the indices in sequences such that has a global rank less than and .
<b id="mwBgE">algorithm</b><span typeof="mw:Nowiki" id="mwBgI"> msSelect(S : Array of sorted Sequences [S_1,..,S_p], k : int) </span><b id="mwBgM">is</b> <b id="mwBgQ">for</b> i = 1 <b id="mwBgU">to</b> p <b id="mwBgY">do</b> (l_i, r_i) = (0, |S_i|-1) <b id="mwBgc">while</b> there exists i: l_i < r_i <b id="mwBgg">do</b> // pick <a rel="mw:WikiLink" href="./Pivot_element" title="Pivot element" id="mwBgk">Pivot Element</a> in S_j[l_j], .., S_j[r_j], chose random j uniformly v := pickPivot(S, l, r) <b id="mwBgo">for</b> i = 1 <b id="mwBgs">to</b> p <b id="mwBgw">do</b> m_i = binarySearch(v, S_i[l_i, r_i]) // sequentially <b id="mwBg0">if</b> m_1 + ... + m_p >= k <b id="mwBg4">then</b> // m_1+ ... + m_p is the global rank of v r := m // vector assignment <b id="mwBg8">else</b> l := m <b id="mwBhA">return</b> l
For the complexity analysis the PRAM model is chosen. If the data is evenly distributed over all , the p-fold execution of the binarySearch method has a running time of . The expected recursion depth is as in the ordinary Quickselect. Thus the overall expected running time is .
Applied on the parallel multiway merge sort, this algorithm has to be invoked in parallel such that all splitter elements of rank for are found simultaneously. These splitter elements can then be used to partition each sequence in parts, with the same total running time of .
Pseudocode
Below, the complete pseudocode of the parallel multiway merge sort algorithm is given. We assume that there is a barrier synchronization before and after the multisequence selection such that every processor can determine the splitting elements and the sequence partition properly.
/** * d: Unsorted Array of Elements * n: Number of Elements * p: Number of Processors * return Sorted Array */ <b id="mwBiE">algorithm</b> parallelMultiwayMergesort(d : Array, n : int, p : int) <b id="mwBiI">is</b> o := <b id="mwBiM">new</b> Array[0, n] // the output array <b id="mwBiQ">for</b> i = 1 <b id="mwBiU">to</b> p <b id="mwBiY">do in parallel</b> // each processor in parallel <span typeof="mw:Nowiki" id="mwBic"> S_i := d[(i-1) * n/p, i * n/p] // Sequence of length n/p</span> sort(S_i) // sort locally <b id="mwBig">synch</b> v_i := msSelect([S_1,...,S_p], i * n/p) // element with global rank i * n/p <b id="mwBik">synch</b> (S_i,1, ..., S_i,p) := sequence_partitioning(si, v_1, ..., v_p) // split s_i into subsequences o[(i-1) * n/p, i * n/p] := kWayMerge(s_1,i, ..., s_p,i) // merge and assign to output array <b id="mwBio">return</b> o
Analysis
Firstly, each processor sorts the assigned elements locally using a sorting algorithm with complexity . After that, the splitter elements have to be calculated in time . Finally, each group of splits have to be merged in parallel by each processor with a running time of using a sequential p-way merge algorithm. Thus, the overall running time is given by
.
Practical adaption and application
The multiway merge sort algorithm is very scalable through its high parallelization capability, which allows the use of many processors. This makes the algorithm a viable candidate for sorting large amounts of data, such as those processed in computer clusters. Also, since in such systems memory is usually not a limiting resource, the disadvantage of space complexity of merge sort is negligible. However, other factors become important in such systems, which are not taken into account when modelling on a PRAM. Here, the following aspects need to be considered: Memory hierarchy, when the data does not fit into the processors cache, or the communication overhead of exchanging data between processors, which could become a bottleneck when the data can no longer be accessed via the shared memory.
Sanders et al. have presented in their paper a bulk synchronous parallel algorithm for multilevel multiway mergesort, which divides processors into groups of size . All processors sort locally first. Unlike single level multiway mergesort, these sequences are then partitioned into parts and assigned to the appropriate processor groups. These steps are repeated recursively in those groups. This reduces communication and especially avoids problems with many small messages. The hierarchical structure of the underlying real network can be used to define the processor groups (e.g. racks, clusters,...).
Further variants
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. 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. Powers further shows that a pipelined version of Batcher's Bitonic Mergesort at O((log n)2) time on a butterfly sorting network is in practice actually faster than his O(log n) sorts on a 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 merge sort for sorting RAM-based arrays. Quicksorts are preferred when the data size to be sorted is lesser, since the space complexity for quicksort is O(log n), it helps in utilizing cache locality better than merge sort (with space complexity O(n)). 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, the 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. The Linux kernel uses merge sort for its linked lists.
Timsort, a tuned hybrid of merge sort and insertion sort is used in variety of software platforms and languages including the Java and Android platforms and is used by Python since version 2.3; since version 3.11, Timsort's merge policy was updated to Powersort.