统计数组中出现次数最多的元素 用c写

可以使用哈希表来实现统计数组中出现次数最多的元素。具体步骤如下：

1. 定义一个哈希表，用来存储每个元素出现的次数。
2. 遍历数组，将每个元素作为哈希表的键值，出现的次数作为哈希表的值。
3. 遍历哈希表，找到出现次数最多的元素。

下面是具体的 C 语言代码实现：

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

#define MAX_SIZE 100

struct node {
    int key;
    int value;
};

struct hashmap {
    int size;
    struct node **data;
};

struct hashmap *create_map(int size) {
    struct hashmap *map = (struct hashmap *)malloc(sizeof(struct hashmap));
    map->size = size;
    map->data = (struct node **)malloc(sizeof(struct node *) * size);
    for (int i = 0; i < size; i++) {
        map->data[i] = NULL;
    }
    return map;
}

int hash_code(struct hashmap *map, int key) {
    int code = key % map->size;
    if (code < 0) {
        code += map->size;
    }
    return code;
}

void put(struct hashmap *map, int key, int value) {
    int code = hash_code(map, key);
    while (map->data[code] != NULL && map->data[code]->key != key) {
        code = (code + 1) % map->size;
    }
    if (map->data[code] == NULL) {
        struct node *new_node = (struct node *)malloc(sizeof(struct node));
        new_node->key = key;
        new_node->value = value;
        map->data[code] = new_node;
    } else {
        map->data[code]->value += value;
    }
}

int get(struct hashmap *map, int key) {
    int code = hash_code(map, key);
    while (map->data[code] != NULL && map->data[code]->key != key) {
        code = (code + 1) % map->size;
    }
    if (map->data[code] != NULL) {
        return map->data[code]->value;
    } else {
        return 0;
    }
}

void free_map(struct hashmap *map) {
    for (int i = 0; i < map->size; i++) {
        if (map->data[i] != NULL) {
            free(map->data[i]);
        }
    }
    free(map->data);
    free(map);
}

int most_frequent(int arr[], int len) {
    struct hashmap *map = create_map(MAX_SIZE);
    int max_freq = 0;
    int max_elem = 0;
    for (int i = 0; i < len; i++) {
        int freq = get(map, arr[i]);
        put(map, arr[i], freq + 1);
        if (freq + 1 > max_freq) {
            max_freq = freq + 1;
            max_elem = arr[i];
        }
    }
    free_map(map);
    return max_elem;
}

int main() {
    int arr[] = {1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1, 1};
    int len = sizeof(arr) / sizeof(int);
    int res = most_frequent(arr, len);
    printf("The most frequent element is %d\n", res);
    return 0;
}

这段代码中，我们首先定义了哈希表的数据结构 `struct hashmap`，其中包含了一个指向节点数组的指针 `data`，以及哈希表的大小 `size`。节点的数据结构 `struct node` 包含了键值 `key` 和值 `value`。

在 `create_map` 函数中，我们创建了一个指定大小的哈希表，并将每个节点初始化为 `NULL`。

在 `hash_code` 函数中，我们使用取模运算将键值映射到哈希表中的索引位置。

在 `put` 函数中，我们首先计算出哈希值，然后遍历节点数组，找到一个空节点或者键值相同的节点，将值加上给定的值。如果没有找到空节点，就创建一个新节点。

在 `get` 函数中，我们首先计算出哈希值，然后遍历节点数组，找到键值相同的节点，返回其值。如果没有找到相同的节点，就返回 0。

在 `most_frequent` 函数中，我们遍历数组，对每个元素进行哈希表操作，更新出现次数最多的元素和其出现次数。最后释放哈希表的内存。

在 `main` 函数中，我们定义了一个数组 `arr`，并调用 `most_frequent` 函数来找到出现次数最多的元素，将其打印出来。