迭代，就地归并排序

Question

For my algorithms class, we were tasked with writing a implementation of merge sort that is iterative instead of recursive, and in-place instead of requiring another array. Since this for a class, I don't want any code given to me, but I cannot figure out the basic algorithm of what to do. A google search doesn't give anything besides code, or explanations that I don't understand, so that isn't a help.

What I currently understand to do is sort all the sub-arrays of size 1 (which is of course trivial), then merge those of size 2, size 4, and so on, but this seems much closer to insertion sort, and then there is the issue of how to use a constant amount of extra space.

As a final note, I am not allowed to use any C++ standard library functions or classes, such as vectors, stacks, any of the sorts, etc.

Answer 1

An iterative algorithm that uses a "kind of" merge sort to sort an array in-place could look like below.

Let's take this unsorted array as example:

4, 3, 8, 5, 9, 2, 5, 1, 7, 10, 8, 0, 3

The algorithm will have an outer loop on the size of the merged arrays. So at the start this size is 1 (nothing has been merged yet). Then in each iteration this size is doubled, which effectively takes two already sorted, consecutive segments together in a merge.

The actual merge will use two indexes in the to-be-merged segment: one at the start of each of the two segments that are to be merged.

As long as the value at the left index is less or equal to the other value, the left index is incremented (moves to the right). In the other case the most complex operation in this algorithm is executed:

The values between the two indexes are shifted to the right and the rightmost of those (the value at the second index) is moved to the first index. So the values cycle around one position. After this cycle, both indexes are incremented.

This process is repeated until either the left index reaches the right index, or the right index reaches the end of the second segment (which can be the end of the array). When this happens the merge is complete, and the two segments will be considered as one in the next iteration of the outer loop.

Here are some images illustrating these steps as they would be performed on the example data:

Here the merge is performed to make segments of size two. Sometimes the last segment will not have a full size, but that is not a problem. For each of the colored segments, the two indexes are placed, one pointing at the first of the two values, and the other to the second value. Where the first value is greater than the second, they are swapped. In case of a swap both indexes are incremented and the second index reaches the end of the second segment (which was only 1 value wide), and so the merge ends. In case no swap happens, only the first index increments, but reaches the second one, so then also the merge ends (without having made changes).

It becomes more interesting in the second iteration of the outer loop:

The first segments to be joined are [3 4] and [5 8]. The two indexes point to 3 and 5 respectively (underlined in blue). The left index is incremented as long as the corresponding value is not greater than the value at the second index. In this case that means the first index reaches the second without any changes. For the second pair of segments, there is more work to do:

Now [2 9] and [1 5] need to be merged. As 2 is greater than 1 the cycling operation kicks in: 1 has to be shifted in, pushing the 2 and 9 one position to the right. Both indexes are incremented. Now 2 is not greater than the other value (5), so only the first index is incremented. Finally, 9 is greater than 5, so they need to be swapped, and then the merge is complete for these segments.

A similar sequence of operations is executed for the next pair of segments:

The last "pair" of segments, really does not have a second segment: the second index points beyond the array end, so there the merge stops immediately.

Again the outer loop iterates, doubling the segment size. Now the following has to be merged:

Note how the 1 (at the second index) is shifted in before [3 4 5 8], which all move one position to the right to make room for it. The same happens with the 2: it is shifted in before the same 4 values again. But then we find that 3 is not greater than five, and the first index increments until it points to the 8. There the 5 is injected before the 8. Finally, 8 is not greater than 9 so the second index reaches the end point.

I will not present the same for the other segment, and the final iteration of the outer loop, which will do one more merge.

As you requested, I provide no code ;-)

Some considerations

Although this could be named a merge sort, the cycling of values really defeats the efficiency of the original algorithm in the worst case scenarios. True, the number of comparisons is still the same, but the number of moves can be more. Take for instance the values [3 4 5 8] which are moved twice to make room for a moving 1 and moving 2. This already totals to 10 moves (and the merge in that step is not yet complete), while the original merge sort will always make the same number of moves as there are values in the segments that are being merged. In the better cases, this algorithm needs no movements at all, or fewer than the original algorithm.

This method guarantees a stable sort.

Answer 2

You mention constant space and in place.

If the in place merge sort doesn't have to be stable, you can swap elements instead of moving them between arrays. Do a merge sort on the left half of the array into the right half of the array, swapping the merged output with the right half of the array, so that the merged output ends up in the right half of the array, and what was in the right half of the array ends up swapped to the left half of the array, reordered (this is the unstable part) but unsorted.

Merge sort the 2nd quarter into the 1st quarter of the array, so that the 1st quarter ends up with sorted data, the 2nd quarter ends up with reordered but unsorted data. Then merge the 1st quarter with the 2nd half of the array into the array starting at the beginning of the 2nd quarter again swapping during the merge operation. The last 3/4s of the array ends up sorted, and the first 1/4 array is reordered and unsorted.

Merge sort 2nd eighth into 1st eighth, then merge sort 1st eighth with last 3/4 of the array, ending up with last 7/8 sorted and first 1/8 reordered but unsorted.

Continue this until there is only one or two unsorted elements on the left. These can be put in place doing a partial insertion sort for the one or two elements.

---

If using constant space and the merge sort needs to be stable, you can use bottom up merge sort, moving part of the array into the constant space, merge into the now freed space in the array, then repack the array to fill in the one or two gaps left behind by the merge process, and repeat until you reach the last remaining freed part of the array, at which point you can do a normal merge sort using the constant space and the freed part of the array. This completes one pass of the merge sort.