C 使用指针：对整数数组排序的程序，分段错误

我试图制作一个具有以下属性的程序：原型为int*max_排序（int array[]，int laenge，int max）的程序，它对数组中的整数进行排序。在堆上创建一个大小为max+1的整数数组，并用零填充所有位置。然后读取给定给函数的数组。如果读取整数x，则堆上位于x位置的数组的值将递增1。然后覆盖数组：如果读取堆上数组位置i处的值n，则在数组（当前位置）中写入i n次。下面的代码给出了分段错误：

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

int *max_sorted(int array[],int laenge, int max){
  int k,l;
  int *ptr;

  ptr= malloc((max+1)*sizeof(int)); /*allocates memory for new array*/
  if(ptr==NULL || max<0){
    return NULL;   /*error*/
  }
  for(k=0; k<max+1; k++){      /*sets all values of ptr array to 0*/
    ptr[k]=0; 
  }


  for(k=0;k<laenge;k++){               
    ptr[array[k]]++;      
   }



  for(k=0;k<max+1;k++){
    if(ptr[k]!=0){
    array[k-l]=k*ptr[k]; 
    }
    else{
      l++;
    }
  }




  free(ptr);
  return array;
}





int main(void){


  int array[3]={2,1,3};
  int laenge=3;
  int max=3;
  int k;
  int*ptr;
  ptr=max_sorted(array,laenge,max);
   for(k=0;k<laenge;k++){
    printf("%d",ptr[k]);
   } 



    return 0;
}

#包括
#包括
#包括
int*max_排序（int数组[]，int laenge，int max）{
int k，l；
int*ptr；
ptr=malloc（（max+1）*sizeof（int））；/*为新数组分配内存*/
如果（ptr==NULL | | max，则编辑的发布代码仍然不正确

下面是一个版本的代码

干净地编译
执行所需的功能
仍然依赖于数组的内容来避免未定义的行为
现在是代码

#include <stdio.h>   // printf()
#include <stdlib.h>  // calloc(), free(), exit(), EXIT_FAILURE



int *max_sorted(int array[], 
                size_t laenge, 
                size_t numElementsInArray);



int main( void )
{
    int array[] = { 2,1,3 };
    size_t laenge=3;

    size_t k;
    int*ptr;

    ptr=max_sorted( array, laenge, sizeof( array )/sizeof(int) );

    for( k=0; k<(sizeof( array )/sizeof(int)); k++)
    {
        printf( "%d ", ptr[k] );  //<-- note space in format string
    }

    return 0;         // <-- in modern C, when main returns 0, this line not needed
} // end function: main


int *max_sorted( int array[],      // array to be sorted
                 size_t laenge,    // largest value in array
                 size_t numElementsInArray ) 
{
    int *ptr = calloc( numElementsInArray+1, sizeof(int) ); /*allocates memory for new array*/
    if(!ptr)
    { // then calloc failed
        perror( "calloc for temporary array failed" );
        exit( EXIT_FAILURE );
    }

    // implied else, malloc successful

    for( size_t i=0; i<laenge; i++ )
    {
        ptr[ array[i] ]++;      // <-- this will have undefined behavior
                                //     when array[i] > 3
    }

    size_t index2 = 1;
    for( size_t index1=1; index1<(numElementsInArray+1); index1++ )
    {
        if( ptr[index1] )
        {
            array[index1-index2] = (int)index1 * ptr[index1];
        }

        else
        {
            index2++;
        }
    }

    free(ptr);
    return array;
} // end function: max_sorted

在
max\u sorted
中，
l
变量从来没有初始化过。哦，天啊，我太笨了……谢谢！为什么你有
max
和
laenge
。你的数组只有一个长度。@MichaelWalz
ptr
指向一个数组，该数组计算
数组中每个值的实例数
max
是多少e与
数组中的最高值相同。不过，我不理解该算法的其余部分。@JeremyP P.S:如果数组中的数字不重复，该算法似乎工作正常。注意：如果
main（）
中的行更改为：
int array[]={2,1310}；size_t laenge=310；
则当前答案将导致seg故障事件。因此，当前逻辑不正确。因此，您需要将第二个参数澄清为
max_sorted（）
或修改逻辑
#include <stdio.h>   // printf()
#include <stdlib.h>  // calloc(), free(), exit(), EXIT_FAILURE



int *max_sorted(int array[], 
                size_t laenge, 
                size_t numElementsInArray);



int main( void )
{
    int array[] = { 2,1,3 };
    size_t laenge=3;

    size_t k;
    int*ptr;

    ptr=max_sorted( array, laenge, sizeof( array )/sizeof(int) );

    for( k=0; k<(sizeof( array )/sizeof(int)); k++)
    {
        printf( "%d ", ptr[k] );  //<-- note space in format string
    }

    return 0;         // <-- in modern C, when main returns 0, this line not needed
} // end function: main


int *max_sorted( int array[],      // array to be sorted
                 size_t laenge,    // largest value in array
                 size_t numElementsInArray ) 
{
    int *ptr = calloc( numElementsInArray+1, sizeof(int) ); /*allocates memory for new array*/
    if(!ptr)
    { // then calloc failed
        perror( "calloc for temporary array failed" );
        exit( EXIT_FAILURE );
    }

    // implied else, malloc successful

    for( size_t i=0; i<laenge; i++ )
    {
        ptr[ array[i] ]++;      // <-- this will have undefined behavior
                                //     when array[i] > 3
    }

    size_t index2 = 1;
    for( size_t index1=1; index1<(numElementsInArray+1); index1++ )
    {
        if( ptr[index1] )
        {
            array[index1-index2] = (int)index1 * ptr[index1];
        }

        else
        {
            index2++;
        }
    }

    free(ptr);
    return array;
} // end function: max_sorted

1 2 3