Countsort "core dumped" error - c

Question

I'm trying to implement a count sort algorithm in c but I'm getting this "core dumped" compiler message. Does anyone know where my mistake is?
I need to sort an array filled with numbers from an external file.
MY CODE:
#include <stdio.h>
#include <stdlib.h>
#include "arrayio.h"
int MAX_LAENGE = 1000;
int MAX_VALUE = 100;
void count_sort_calculate_counts(int input_array[], int len, int count_array[])
{
count_array = (int*)calloc(MAX_VALUE, sizeof(int));
for(int i = 0; i < MAX_VALUE; i++)
{
count_array[i] = 0;
}
for(int j = 0; j <= len; j++)
{
count_array[input_array[j]] = count_array[input_array[j]] +1;
}
}
void count_sort_write_output_array(int output_array[], int len, int count_array[])
{
int k = 0;
for(int i = 0; i < MAX_VALUE; i++)
{
for(int j = 0; j < count_array[i]; j++)
{
output_array[k] = i;
k = k + 1;
}
}
}
int main(int argc, char *argv[]) {
if (argc < 2){
printf("Aufruf: %s <Dateiname>\n", argv[0]);
printf("Beispiel: %s zahlen.txt\n", argv[0]);
exit(1);
}
char *filename = argv[1];
int input_array[MAX_LAENGE];
int len = read_array_from_file(input_array, MAX_LAENGE, filename);
printf("Unsortiertes Array:");
print_array(input_array, len);
int count_array[MAX_VALUE];
int output_array[MAX_LAENGE];
count_sort_calculate_counts(input_array, len, output_array);
count_sort_write_output_array(output_array, len, count_array);
printf("Sortiertes Array:");
print_array(output_array, len);
free(count_array);
return 0;
}
I thought about it for days but I can't solve it.

Answer 1

this loop:
for(int j = 0; j <= len; j++)
{
count_array[input_array[j]] = count_array[input_array[j]] +1;
}
goes 1 int too far so reads input_array[j] out of input_array bounds. Reading one more rarely triggers a crash, but the value is completely random & possibly very high so count_array[input_array[j]] accesses a very far address, very much out of bounds, hence the crash.
fix proposal (& small simplification):
for(int j = 0; j < len; j++)
{
count_array[input_array[j]] ++;
}

Answer 2

First thing, why do you need to allocate memory dynamically?
count_array = (int*)calloc(MAX_VALUE, sizeof(int));
You only need to allocate memory dynamically if you don't have an idea how much memory is required. Thats the case when you'd use calloc() and malloc() primarily.
In main() function,
int count_array[MAX_VALUE];
This has already allocated memory (Size = MAX_VALUE x size of int) for count_array compile-time. So, you can get rid of the code which involves calloc().
If you want to initialize all array contents to 0, then you can use:
int count_array[MAX_VALUE] = {0};
Secondly, there is an array going out of bounds:
for(int j = 0; j <= len; j++)
Change it to
for(int j = 0; j < len; j++)

Answer 3

when the code is going to change where a pointer, in the calling function, is pointing via some activity in a called function, then the pointer to the called function must be passed as the address of the pointer.
Similar to:
in function: main()
int *output_array = NULL;
count_sort_calculate_counts(input_array, len, &output_array);
in function: count_sort_calculate_counts()
void count_sort_calculate_counts(int input_array[], int len, int **count_array)
*count_array = calloc(MAX_VALUE, sizeof(int));
if( !(*count_array) )
{
// handle error then exit program
}
this code block:
for(int j = 0; j <= len; j++)
{
count_array[input_array[j]] = count_array[input_array[j]] +1;
}
can be greatly simplified to:
for(int j = 0; j <= len; j++)
{
(*count_array)[input_array[j]] += 1;
}