Question

大家好，所以我的MergeSort算法并不完美，它实际上与在类似问题中发布的相同，但这甚至都不是真正的问题。基本上用户输入数组大小，并且更低和更低。要放入要合并的双精度数组的一系列值的上限。

我可以很好地打印出数组，但是在MergeSort之后它返回了我认为是地址的whack负值。

我知道这与记忆有关，但我不知道它为什么会搞乱，因为我相信我分配了内存并正确清除了它。这是我的代码，特别是在今晚12:00之前，我们将非常感谢任何见解;）。

这是main.c，mergesort.c和mergesort.h。我也在使用makefile，但我认为没有必要分享。

MAIN.C：

#include <stdlib.h>
#include <stdio.h>
#include "mergesort.h"

int lower = 0;
int upper = 0;
int n = 0;

int main(int argc,char* argv[]) {

    int i = 0; // loop values
    int j = 0;
    int r = 0; // random number

    /*int n = 0; // size of array
    int lower = 0; // lower bound on values in array
    int upper = 0; // upper ...*/

    double *t; //array of doubles

    printf("Size of array?\n");
    scanf("%d", &n);

    printf("Lower Bound?\n");
    scanf("%d", &lower);
    //globLower = lower;

    printf("Upper Bound?\n");
    scanf("%d", &upper);
    //globUpper = upper;

    t = malloc(n * sizeof *t); // allocates n slots of memory


    printf("Unsorted Array:\n");

    for(i=0; i<n; i++) {
        r = lower + arc4random() % (upper - lower);

        //printf("%d\n", r);
        t[i] = r;   // fills array with random values in range
        printf("%g\n", t[i]);
    }


    printf("Before Merge Sort\n");

    mergeSort(t,n); // This is supposed to sort the array...

    printf("After Merge Sort\n");

    i = 0; //reset
        // printf("%g\n", t[0]);
        printf("%g\n", t[1]);
        printf("%g\n", t[2]);



    free(t);   // Need to free the memory allocated since is stored in the heap
    return 0; 
 }

mergesort.c：

#include <stdlib.h>
#include <stdio.h>
#include "mergesort.h"

void mergeSort(double* t, int n) {
    printf("Size: %d\n", n);
    printf("Lower: %d\n", lower);     // tests
    printf("Upper: %d\n", upper);
    printf("t[2]: %g\n", t[2]);
    int beg = 0;
    int end = n-1;
    mergeSortHelp(t, beg, end);
}

void mergeSortHelp(double* t, int beg, int end) {
    int mid = (end + beg) / 2;

    if(beg < end) {
        mergeSortHelp(t, beg, mid);
        mergeSortHelp(t, mid+1, end);
        merge(t, beg, mid, end);
    }
}

void merge(double* t, int beg, int mid, int end) {
    int sizeLeft = mid - beg + 1;
    int sizeRight = end - mid;
    double *left = malloc((sizeLeft)*sizeof(double));
    double *right = malloc((sizeRight)*sizeof(double));
    int i,j,k;

for(i = 0; i < sizeLeft; i++) {
    left[i] = t[beg+i];
}
for(j = 0; j < sizeRight; j++) {
    right[i] = t[beg+j];
}

i = 0;
j = 0;

for(k = beg; k <= end; k++) {
    t[k] = (left[i] <= right[j]) ? left[i++] : right[j++];
}

free(left);
free(right);

return;
}

和标题mergesort.h

extern int lower;   
extern int upper;
extern int n;

谢谢！

Answer 1

看起来你可能有两个错误：

for(j = 0; j < sizeRight; j++) {
    right[i] = t[beg+j];

这应该是：

for(j = 0; j < sizeRight; j++) {
    right[j] = t[med+j];
         ^^^     ^^^

使用malloc，内存概率的双动态数组的Mergesort

1 个答案: