合并排序错误的输出

Question

I'm trying to use the following merge sort function to sort an array. However it is not giving me the expected output. It will not print out correct/expected output ie

Input: 5,4,3,2,1
Output: 1,2,3,4,5

Instead it gives: 2,3,4,5,1,9,8,7,8,4,1,8,8,2.

#include <iostream>
#include <cmath>
#include <ctime>
#include <cstdlib>

using namespace std;

void mergeSort(int a[], int low , int high,int res[]);
void merge(int a[], int low , int mid , int high,int res[]);
void mergeSort(int numbers[], int temp[], int array_size);

const int SIZE=5;

int main () {

    int sorted[SIZE];
    for (int i=0; i<SIZE; i++) {
        cout << "input numbers" <<endl;
        cin >>sorted[i];
    }
    int merge[SIZE];

    mergeSort(sorted,merge,SIZE);

    for (int i=0; i<SIZE; i++) {
        cout << merge[i];
    }

    return 0;
}

void mergeSort(int numbers[], int temp[], int array_size)
{
    mergeSort(numbers, 0, array_size-1, temp);
}

void mergeSort(int a[], int low , int high,int res[])
{
    int mid = (low + high)  /2;
    if (low + 1 < high)
    {
        //  Sort sub-parts
        mergeSort(a,low,mid,res);
        mergeSort(a,mid,high,res);

        //  Merge back to "res"
        merge(a,low,mid,high,res);
    }else{
        res[low] = a[low];
    }
}

void merge(int a[], int low , int mid , int high,int res[])
{
    int i = low;
    int j = mid;
    int k = low;   //  Use "low" instead of 0.

    while (i < mid && j < high)
        if(a[i] < a[j])
            res[k++] = a[i++];
        else
            res[k++] = a[j++];

    while (i < mid)
        res[k++] = a[i++];

    while (j < high)
        res[k++] =a[j++];

    //  Copy back to "a"
    for (int c = low; c < high; c++){
        a[c] = res[c];
    }
}

Answer 1

I think this is causing the problem --

    //  Sort sub-parts
    mergeSort(a,low,mid,res);
    mergeSort(a,mid,high,res);

It should be

    //  Sort sub-parts
    mergeSort(a,low,mid,res);
    mergeSort(a,mid+1,high,res);

Also if (low + 1 < high) should be changed to if (low < high)

Furthermore while (i < mid && j < high) should be while (i <= mid && j <= high) and single while loops below it too need to be updated with <=

Answer 2

There is a bit of confusion in your handling of indexing limits.

Two very common ways to represent ranges are:

1. range limits are pointing between elements
2. range limits are pointing to elements

In the picture the numbering above is using the "pointing between elements" approach and the grayed out range is (2, 5) .

The numbering below is instead using the "pointing to elements" approach and the same range is (2, 4) .

As a personal preference I like the "between elements" approach much more: for example the size of a range is high-low and you can represent easily empty ranges or even inverted ranges. The important thing is however that you keep always clear in your mind if you're using the first or the second approach when writing code that is managing ranges.

In your code there's that kind of confusion; for example in mergesort you are checking if

low + 1 < high

and this means that you're using the "between elements" approach because when high - low = 1 means there is only one element and no sorting is needed. Also you recurse passing (low, mid) and (mid, high) : another clear sign that the "between elements" approach is used because you surely don't want to move around array[mid] twice.

In the same code however you're passing the function 0 and array_size-1 in the main program, a clear sign that in this case you're using the "pointing to elements" approach instead.

Just double-check that all your index and range usage is coherent and the code will be fine.

Answer 3

According to your sample code, only 5 numbers should be printed as result (because of const int SIZE=5 ).

That aside, note that you provide the position of the last element of your list as "high" parameter.

However, in your merge function, your while(j < high) conditions make sure that this last element in the list will not be sorted, because sorting stops just before reaching it.

Update: The for loop at the end of the merge function needs to be adapted to also copy the last ("high") element back into the array a .