how to size and fill malloc array in C with bits

Question

I think to initialize an array of size n filled with ints would be:

int *ptr = (int*)malloc(n * sizeof(int))

To fill array ptr with numbers from 0 to n would be:

for (int j = 0; j< n; j++){
        ptr[j] = j;
}

Now I actually have an input array of size n, with random values that can be represented up to 16 bits. I think this means that there can be numbers valued up to 65,535?

I need to sort the input array using counting sort so I need to create a new array.

Does this mean instead of the n I used before for the size of ptr array, I replace it with 65,535 so that every possible value can fit in my array?

Answer 1

Counting sort is where the keys (in this case, numbers) are placed into buckets. The buckets contain frequency of keys that are in their range. This is in much the way as a histogram . In the case where the buckets have just one key (as is your case), you can reconstruct the original keys by generating the key of the bucket times the frequency.

It's confusing to have the range be [0, 65,536) and the domain be [0, n) . Perhaps a range of fruits would be clearer.

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

#define FRUITS X(banana), X(pear), X(apple), X(kiwi), X(pomegranate), X(mango)
#define X(n) n
enum fruits { FRUITS };
#undef X
#define X(n) #n
static const char *const fruit_name[] = { FRUITS };
#undef X

int main(void) {
    enum fruits nu,
        fruits[] = { banana, apple, kiwi, pear, kiwi, banana, mango };
    size_t n,
        freq[sizeof fruit_name / sizeof *fruit_name] = { 0 };

    /* `O(n)` to go though `fruits` and make `freq`. */
    for(n = 0; n < sizeof fruits / sizeof *fruits; n++) freq[fruits[n]]++;

    /* `O(n)` to rebuild `fruits` from `freq` in order. */
    for(n = 0, nu = 0; nu < sizeof fruit_name / sizeof *fruit_name; nu++) {
        size_t iter = 0;
        printf("%s\t%zu\n", fruit_name[nu], freq[nu]);
        for(iter = 0; iter < freq[nu]; iter++) fruits[n++] = nu;
    }

    /* `O(n)` to display. */
    for(n = 0; n < sizeof fruits / sizeof *fruits; n++)
        printf("%s\n", fruit_name[fruits[n]]);
    return EXIT_SUCCESS;
}

In this case, int *ptr is freq[] . It starts freq[j] = 0 , not freq[j] = j . Note that the frequencies are never negative, in this case I've used a size_t .

If you require a large range of freq , than you should be thinking of dynamic memory allocation because the danger of stack overflow. How many frequencies can fit into one bin depends not on the range of fruit, (in your case, 16-bits,) but on n , the size of your list.