Question

我找到了python的答案，但我对此并不了解。

代码是经过修改的合并排序。对于我检查到的少量输入，它工作正常。但是当我通过在线判断运行时，当输入数量很高（500）时，它给了我这个错误：

Error in 'a.out': corrupted size vs. prev_size: 0x0000000000d5b8b0
======= Backtrace: =========
/lib/x86_64-linux-gnu/libc.so.6(+0x777e5)[0x7f3b83a5b7e5]
/lib/x86_64-linux-gnu/libc.so.6(+0x80dfb)[0x7f3b83a64dfb]
/lib/x86_64-linux-gnu/libc.so.6(cfree+0x4c)[0x7f3b83a6853c]
a.out[0x4009d1]
a.out[0x400ac7]
a.out[0x400a87]
a.out[0x400aa4]
a.out[0x400a87]
a.out[0x400bc7]
/lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7f3b83a04830]
a.out[0x4005b9]
======= Memory map: ========

它还有15行。为什么我收到此错误？是因为我在使用malloc动态分配内存时犯了一些错误吗？

这是我的代码：

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

void *Merge(int *A,int l,int m,int r,int *B,int *F);
void *Merge(int *A,int l,int m,int r,int *B,int *F){
  int i=l,j=m,k=0,*C,x,y=l,z,cSize,temp,*D,*E;

  cSize = r-l;
  C = (int *) malloc (cSize * sizeof(int));
  D = (int *) malloc (cSize * sizeof(int));
  E = (int *) malloc (cSize * sizeof(int));

  while (k < cSize){
    if((j==r) || ((i!=m) && ((A[j]*B[i]) >= (A[i]*B[j])))){
        C[k] = A[i];
        D[k] = B[i];
        E[k] = F[i];
        i++;
        k++;
    }
    if((i>=m) || ((j!=r) && ((A[j]*B[i]) < (A[i]*B[j])))){
        C[k] = A[j];
        D[k] = B[j];
        E[k] = F[j];
        j++;
        k++;
    }
  }
  for(x=0;x<k;x++){
    A[y] = C[x];
    B[y] = D[x];
    F[y] = E[x];
    y++;
  }
  free(C);
  free(D);
  free(E);
}

void *MergeSort(int *A,int left,int right,int *B,int *C);
void *MergeSort(int *A,int left,int right,int *B,int *C){
  int mid,i,j,k=0,l=0,*R,*L;
  if(right - left == 1){
    A[left] = A[left];
  }
  if(right-left > 1){
    mid = (left+right)/2;

    MergeSort(A,left,mid,B,C);
    MergeSort(A,mid,right,B,C);

    Merge(A,left,mid,right,B,C);
  }
}

int main(){
  int n,i=0,newNumt,newNumo,*a,*b,*c;

  scanf("%d",&n);
  a = (int *) malloc (n * sizeof(int));
  b = (int *) malloc (n * sizeof(int));
  c = (int *) malloc (n * sizeof(int));

  for(i=0;i<n;i++){
    scanf("%d %d",&a[i],&b[i]);
    c[i]= i+1;
  }
  MergeSort(a,0,n,b,c);
  for(i=0;i<n;i++){
    printf("%d\n",c[i]);
  }

  return 0;
}

Answer 1

这是一个过时的帖子，但是有几个问题未解决，因此，下面的尝试来解决您在帖子中特别提到的一些问题。

如注释中所述，通过在编译过程中设置-Wall，然后通过调试器运行它，并在提示下输入多达20组整数对，可以找到导致您所陈述的主要问题的问题的性质。

以下是您的完整代码，并进行了一些修改。有些只是建议，而有些则是对编译警告的响应，有些比其他重要。这些都被评论了。

解决您的主要问题之一：为什么会出现此错误？是因为我在使用malloc动态分配内存时犯了一些错误？：
如我的@Jonathan Leffler所述，内存分配不太可能出现问题，但是尝试访问未分配的内存。
运行未经修改的代码时，会看到与此相关的值得注意的运行时错误，并且该错误在Merge()函数中用注释标记，其中索引k的值增加到应有的值，导致越界指针取消引用错误。快速解决方案是通过在第二部分中添加一个if使两个else部分互斥。此修改确实可以防止运行时错误，但不一定是所需的正确（或唯一）更改。

我没有在代码中解决的另一个建议是选择变量名。正如所写的那样，许多内容太晦涩难懂，不能增加可读性或对代码试图执行的操作的理解。建议使用变量名，该变量名将允许另一个人（甚至是您自己，三年以后，您将再次查看它。）立即了解变量的用途。

阅读注释以了解更改的原因...

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

void *Merge(int *A,int l,int m,int r,int *B,int *F);
void *MergeSort(int *A,int left,int right,int *B,int *C);

int main()
{
   // int n,i=0,newNumt,newNumo,*a,*b,*c;
    int n,i=0,*a,*b,*c; //removed unused newNumt & newNumo

    printf("\nEnter number of integer pairs:\n");//user input instructions
    scanf("%d",&n);
    a = calloc (n, sizeof(int));//see comment in MergeSort for similar
    b = calloc (n, sizeof(int));//suggested change for malloc/calloc
    c = calloc (n, sizeof(int));

    for(i=0;i<n;i++)
    {
        printf("\n%d) Enter two integer values:\n", i);//user input instructions
        scanf("%d %d",&a[i],&b[i]);
        c[i]= i+1;
    }
    MergeSort(a,0,n,b,c);
    for(i=0;i<n;i++)
    {
        printf("%d\n",c[i]);
    }

    return 0; 
}

void *Merge(int *A, int l, int m, int r, int *B, int *F)
{
    //int i=l,j=m,k=0,*C,x,y=l,z,cSize,temp,*D,*E;    
    int i=l,j=m,k=0,*C,x,y=l,cSize,*D,*E;//removed unused z and temp

    cSize = r-l;
   // C = (int *) malloc (cSize * sizeof(int));
   // D = (int *) malloc (cSize * sizeof(int));
   // E = (int *) malloc (cSize * sizeof(int));
    C = calloc (cSize, sizeof(int)); //it is not recommended to cast the return
    D = calloc (cSize, sizeof(int)); //of malloc/calloc/realloc in C
    E = calloc (cSize, sizeof(int)); //changed malloc to calloc to initialize
                                      //variable memory to zero before use

// Only one or the other of the following two if statements should be executed per loop, 
// by running both an access violation occurs causing crash. (eg. when k is incremented twice 
// before being tested.) 
    while (k < cSize)//k is tested only once per loop...
    {
        if((j==r) || ((i!=m) && ((A[j]*B[i]) >= (A[i]*B[j]))))
        {
            C[k] = A[i];
            D[k] = B[i];
            E[k] = F[i];
            i++;
            k++;//if k == csize-1, it will be incremented to k == csize, then go into the next section
        }
        else if((i>=m) || ((j!=r) && ((A[j]*B[i]) < (A[i]*B[j])))) //added else
        {
            C[k] = A[j]; //Dereference of out-of-bounds pointer occurs here when k is too large.
            D[k] = B[j];
            E[k] = F[j];
            j++;
            k++;// ... but possibly increment twice!
        }
    }
    for(x=0;x<k;x++)
    {
        A[y] = C[x];
        B[y] = D[x];
        F[y] = E[x];
        y++;
    }
    free(C);
    free(D);
    free(E);

    return 0; //function prototype requires a return to quiet the warnings
              //Only void function prototypes do not require a return statement

}


void *MergeSort(int *A,int left,int right,int *B,int *C)
{
    //int mid,i,j,k=0,l=0,*R,*L;
    int mid = 0; //removed all unused variables and initialized mid

    if(right - left == 1)
    {
        A[left] = A[left];
    }
    if(right - left > 1)
    {
        mid = (left + right)/2; // integer rounding

        MergeSort(A, left, mid, B, C);
        MergeSort(A, mid, right, B, C);

        Merge(A, left, mid, right, B, C);
    }

    return 0; //function prototype requires a return to quiet the warnings
              //Only void function prototypes do not require a return statement

}

Answer 2

我不知道它是否有帮助，但是这里有QuickSort的代码，根据Google的说法，它比MergeSort更好：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void Swap(int array[], int i, int j)
{
  int temp;
  temp = array[i];
  array[i] = array[j];
  array[j] = temp;
}


void QuickSort(int array[], int beg, int end)
{
  int pivot, k, b, e;

    while(beg < end)
    {
      b = beg; k = (beg+end)/2; e = end;
      pivot = array[k];

      while(1)
      {
        while((b <= e) && (array[b] <= pivot)) b++;
        while((b <= e) && (array[e] > pivot)) e--;

        if(b > e) break;


      Swap(array, b, e);

        if(k == e) k = b;

        b++; e--;

      }
      array[k]=array[e];
      array[e]=pivot;
      e--;

      if((e-beg)<(end-b))
      {
        QuickSort(array, beg, e);
        beg = b;
      }
      else
      {
        QuickSort(array, b, end);
        end = e;
      }

    }

  return ;
}

void display(int * array, int n)
{
 for(int i = 0; i < n ; i++)
 {
   printf("%d\n", array[i]);
 }
}


int main()
{
  int array[] = {1,2,77,5,42,33,0,4,12,21,55};

  QuickSort(array,0,sizeof(array)/sizeof(int));

  display(array, sizeof(array)/sizeof(int));


  return 0;
}

也许问题出在主函数上，您应该使用sizeof(array)/sizeof(int)传递要排序的数组的大小。看看是否有帮助。

使用malloc的C中的错误：corrupted size vs prev_size

2 个答案: