帮我写一段关于LFU淘汰算法的C语言核心代码

好的，以下是一段简单的 LFU 淘汰算法的 C 语言核心代码：

typedef struct _node {
    int key;
    int value;
    int freq;
    struct _node *prev;
    struct _node *next;
} node;

typedef struct _cache {
    int size;
    int capacity;
    node *head;
    node *tail;
    node **freq;
} cache;

cache *cache_init(int capacity) {
    cache *c = (cache *)malloc(sizeof(cache));
    c->size = 0;
    c->capacity = capacity;
    c->head = NULL;
    c->tail = NULL;
    c->freq = (node **)calloc(capacity + 1, sizeof(node *));
    return c;
}

void cache_set(cache *c, int key, int value) {
    if (c->capacity <= 0) {
        return;
    }
    node *n = c->freq[1];
    if (n != NULL && n->key == key) {
        n->value = value;
        n->freq++;
        return;
    }
    if (c->size >= c->capacity) {
        node *last = c->tail;
        c->freq[last->freq] = last->prev;
        if (last->prev != NULL) {
            last->prev->next = NULL;
        } else {
            c->head = NULL;
        }
        c->size--;
        free(last);
    }
    node *new_node = (node *)malloc(sizeof(node));
    new_node->key = key;
    new_node->value = value;
    new_node->freq = 1;
    new_node->prev = NULL;
    new_node->next = c->freq[1];
    if (new_node->next != NULL) {
        new_node->next->prev = new_node;
    } else {
        c->tail = new_node;
    }
    c->freq[1] = new_node;
    c->size++;
}

int cache_get(cache *c, int key) {
    node *n = c->freq[1];
    while (n != NULL) {
        if (n->key == key) {
            n->freq++;
            if (n->prev == NULL || n->freq > n->prev->freq) {
                if (n == c->tail) {
                    c->tail = n->prev;
                }
                if (n->prev != NULL) {
                    n->prev->next = n->next;
                }
                if (n->next != NULL) {
                    n->next->prev = n->prev;
                }
                n->prev = NULL;
                n->next = c->freq[n->freq];
                if (n->next != NULL) {
                    n->next->prev = n;
                } else {
                    c->tail = n;
                }
                c->freq[n->freq] = n;
            }
            return n->value;
        }
        n = n->next;
    }
    return -1;
}

这段代码实现了一个 LFU 缓存，其中 `cache` 结构体表示缓存，`node` 结构体表示双向链表节点。具体实现细节可以参考代码注释。