C-合并排序的合并部分

Question

I am new to merge sorts and am trying to create one. My merge sort is not sorting the array I am sending it and I can't figure out why. here is a link to all of the code http://pastebin.com/M4RUzhUa

Here is my mergesort function

void merge_sort(int array[], int low, int high) {
        int middle = (low + high) / 2;

        if(low < high) {
                merge_sort(array, low, middle);
                merge_sort(array, middle+1, high);
                merge(array, low, middle, high);
        }
}

Here is my (updated) merge function

void merge(int array[], int low, int middle, int high) {
int size,left,right,i, j;
size = high - low + 1;
int array1[high];

left = low;
right = middle + 1;
i = low;

while ((left<=middle) && (right<=high)) {
        if(array[left] < array[right]) {
                array1[i] = array[left];
                left++;
                i++;
        }
        else {
                array1[i] = array[right];
                right++;
                i++;
        }
}
while (left <= middle) {
        array1[i] = array[left];
        left++;
        i++;
}
while (right <= high) {
        array1[i] = array[right];
        right++;
        i++;
}
for (j = low; j < i; j++) {
        array[j] = array1[j];
}
}

In my program the input array is

9 3 2 1 5

and the output is

0 1 2 3 5

something is happening with the first element that i can't figure out

Answer 1

New comments for updated code:

It looks like you are waltzing past the end of your array. A way to test that would be to add some guard variables around your array, like this:

#define NUM_OF_INTS 5
#define DEBUG 1
int main()
{
    int frontguard=-500;
    int numbers[NUM_OF_INTS];
    int backguard=-600;
    int i;

    srand(0);
    //Fill the array
    for( i = 0; i < NUM_OF_INTS; i++ )
    {
        //Use random numbers
        //numbers[i] = rand()%10000;    

        //Use reverse sorted list
        numbers[i] = NUM_OF_INTS-i;         

        //Use sorted list
        //numbers[i] = i;
    }

    if (DEBUG == 1) printf( "Unsorted list\n" );
    if (DEBUG == 1) printarray( numbers, 0, NUM_OF_INTS/2, NUM_OF_INTS );   
    if (DEBUG == 1) printf( "frontguard=%04d, backguard=%04d\n", frontguard, backguard);

    merge_sort( numbers, 0, NUM_OF_INTS );

    if (DEBUG == 1 ) printf( "\nSorted list\n"); 
    if (DEBUG == 1) printarray( numbers, 0, NUM_OF_INTS/2, NUM_OF_INTS );   
    if (DEBUG == 1) printf( "frontguard=%04d, backguard=%04d\n", frontguard, backguard);

    return 0;
}

printarray is a helper function I wrote to prettyprint what is happening in an array

void printarray( const int arr[], const int low, const int middle, const int high )
{
    int i;
    for (i = low; i < high; i++ )
    {
        if( i == low )
            printf( "   L%04d", i );
        else if( i == middle )
            printf( "   M%04d", i );
        else if( i == (high-1) )
            printf( "   H%04d", i );
        else 
            printf( "   *%04d", i );        
    }
    printf( "\n" );
    for( i = low; i < high; i++ )
        printf( "    %04d", arr[i] );
    printf( "\n" );
}   

It is common to have to create some helper debug functions such as this to get your code working if you do not have/want a debugger. Do not be afraid to write some throw-away code to understand what your code is doing! In this case, I didn't need the line of L/M/H, but it is still worthwhile to spend the time. I recommend leaving these types of functions in your code, commented out (using a #define such as DEBUG), in case a future maintainer needs them.

Here is the output of your function as-is:

Unsorted list
   L0000   *0001   M0002   *0003   H0004
   0005    0004    0003    0002    0001
frontguard=-500, backguard=-600

Sorted list
   L0000   *0001   M0002   *0003   H0004
    -600    0001    0002    0003    0004
frontguard=-500, backguard=0005

You can see that the backguard got overwritten and "stolen" into your output. (This behavior can differ on different CPU architectures, C implementations, and run specifics, btw.) The problem is that you call merge_sort from main() with high as the size of the array (5 in this case), however merge_sort expects high to be the last valid index in the array (numbers[4] is the last array item). Modify main() to

    merge_sort( numbers, 0, NUM_OF_INTS-1 );

and test it against a sorted, reverse sorted, and random array of numbers.

---

Original comments:

Well, first off, you should be receiving a segementation fault, not just incorrectly sorted data.

  size = high - low + 1; //create a helper array and set it equal to the input array int array1[size]; for (i = low; i <= high; i++) { array1[i] = array[i]; } 

Think about what happens here when low is not zero. Let's say l=6, m=6, h=7. You are setting the size of your helper array to 2, but you are accessing it with i=6, so you are trashing the stack.

The easiest fix for this is to declare int array1[high]; . It's memory inefficient but it keeps the rest of the code simple, which is really more valuable.

Second, your for loop is indexing past the end of array, you need to use i < high. In C, arrays start at 0, so an array of size 5 has valid locations at 0,1,2,3,4. Your code as-is would try to read from array[5] (probably not fatal), and write to array1[5] (very possibly fatal). I'll bet this why you have a +1 in the size statement, since you were advancing past the end of array1 otherwise.

  for (i = low; i < high; i++) { 

These will fix your segmentation fault. With that fixed, you are still getting garbage data in your output.

Your middle else-if statement is never going to be executed - any equivalent data is going to be covered by the first if statement.

Your while loop does not properly handle the degenerate cases. It needs to detect if one of the two lists has been completely consumed, and if so, just copy the rest of the other list.

Also, the while loop needs separate tracker variables for low, mid, and the output array. You cannot use currentLow for both low and the output array.

Finally, when testing sorting, random data is not sufficient (esp. with a size of 5), you should always test the totally degenerate cases of a sorted and reverse-sorted lists.