Using an array such as int counts[1000]; is going to limit the integers you can track into the range [0, 999] (that is, greater-than or equal to 0, and less-than or equal to 999). This is fine, as long as you can guarantee each input value is within this range (or otherwise handle values outside the range).
There is no need for a nested loop; simply increment the frequency counter for your current value, and update your maximum if this new count exceeds it.
When it comes time to print: for small ranges, you can just scan it entirely for hits,
for (size_t i = 0; i < MAX_N; i++)
if (freq[i])
printf("Number %zu appears %d times\n", i, freq[i]);
or if performance is a concern, you can sort the array, and only print each value once by resetting the frequency afterwards. Again, you must watch for values outside the valid range.
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX_N 1000
int low_to_high(const void *p1, const void *p2) {
int a = *((int *) p1),
b = *((int *) p2);
return a == b ? 0 : a > b ? 1 : -1;
}
int main(void) {
int input[] = { 1, 2, 1, 4, 2, 4, -5, 2, 2, 3, 4, 2, 1000 };
size_t input_length = sizeof input / sizeof *input;
int freq[MAX_N] = { 0 };
int max_value, max_freq = INT_MIN;
for (size_t i = 0; i < input_length; i++) {
int value = input[i];
if (value >= MAX_N || value < 0) {
fprintf(stderr, "Stray value detected: %d\n", value);
continue;
}
if (++freq[value] > max_freq) {
max_freq = freq[value];
max_value = value;
}
}
qsort(input, input_length, sizeof *input, low_to_high);
for (size_t i = 0; i < input_length; i++) {
int value = input[i];
if (value >= MAX_N || value < 0) {
fprintf(stderr, "Stray value detected: %d\n", value);
continue;
}
if (freq[value]) {
printf("Number %d appears %d times\n", value, freq[value]);
freq[value] = 0;
}
}
printf("Most frequent: %d [%d]\n", max_value, max_freq);
}
stdout:
Number 1 appears 2 times
Number 2 appears 5 times
Number 3 appears 1 times
Number 4 appears 3 times
Most frequent: 2 [5]
stderr:
Stray value detected: -5
Stray value detected: 1000
Stray value detected: -5
Stray value detected: 1000
As we've seen, using an array limits the range of integers you can support. Data structures other than arrays can provide an alternative solution to this problem.
One suggestion would be to use a linked list, so that you can support the entire range of a signed type (in this case, [INT_MIN, INT_MAX]).
Here we add our value to the list with a count of 1 if it has not been seen, otherwise we increment the existing count.
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
struct freq {
int value;
int count;
struct freq *next;
};
struct freq_list {
struct freq *head;
};
struct freq *freq_create(int value, struct freq *next) {
struct freq *node = malloc(sizeof *node);
node->value = value;
node->count = 1;
node->next = next;
return node;
}
int freq_list_increase(struct freq_list *list, int value)
{
if (!list->head || list->head->value > value)
list->head = freq_create(value, list->head);
else {
struct freq *node = list->head;
struct freq *last = NULL;
while (node && node->value < value) {
last = node;
node = node->next;
}
if (!node || node->value > value)
last->next = freq_create(value, node);
else
return ++node->count;
}
return 1;
}
int main(void) {
int array[] = { 1, 2, 1, 4, 2, 4, 2, 2, 3, 4, 2, -1, -1, -1273, 7473, 0, 0, -2000 };
size_t array_length = sizeof array / sizeof *array;
struct freq_list counts = { NULL };
int min = INT_MAX;
int max = INT_MIN;
for (size_t i = 0; i < array_length; i++) {
int val = freq_list_increase(&counts, array[i]);
if (val < min)
min = val;
if (val > max)
max = val;
}
for (struct freq *t = NULL, *n = counts.head; n; n = t) {
printf("%11d appears %11d times.", n->value, n->count);
if (n->count == min)
printf(" (MIN)");
if (n->count == max)
printf(" (MAX)");
putchar('\n');
t = n->next;
free(n);
}
}
Output:
-2000 appears 1 times. (MIN)
-1273 appears 1 times. (MIN)
-1 appears 2 times.
0 appears 2 times.
1 appears 2 times.
2 appears 5 times. (MAX)
3 appears 1 times. (MIN)
4 appears 3 times.
7473 appears 1 times. (MIN)
With this implementation, presorting your input (high-to-low) may provide performance benefits. In any case, this list will sort itself as it is built. This side effect may be desirable in situations where your input cannot be sorted ahead of time.
