缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中有着非常广泛的应用，如常见的CPU缓存、数据库缓存和浏览器缓存。 缓存的大小有限，当缓存被填满时，哪些数据应该被清理？哪些数据应该被保留？这就需要缓存淘汰算法来决定。 LRU（最近最少使用）算法就是一种常用的缓存淘汰算法，算法的设计原则是：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。 我们可以用一个数据结构来维护缓存，访问新的数据时，若缓存未满，可以直接放入缓存，若缓存已满，删除最久未访问的数据后再放入新的数据。当再次访问缓存中已有的数据时，将该数据调整为最新访问。 即该数据结构可能需要做频繁的插入和删除操作，请完成以下问题： （1）为该数据结构设计一种存储结构，用C语言写出类型定义，每个成员加上注释，其中数据定义为int类型。 （2）使用（1）中定义的存储结构，实现LRU算法中的插入新数据操作（需要考虑缓存已满和未满两种情况），自行定义函数名和参数。

好的，我明白了。以下是我的回答：

（1）存储结构的类型定义如下：

#define MAX_CACHE_SIZE 100 // 缓存大小限制

typedef struct CacheNode {
    int key; // 数据的键，用于查找和删除
    int value; // 数据的值
    struct CacheNode* prev; // 指向前一个节点的指针
    struct CacheNode* next; // 指向后一个节点的指针
} CacheNode;

typedef struct LRUCache {
    CacheNode* head; // 指向双向链表头节点的指针
    CacheNode* tail; // 指向双向链表尾节点的指针
    int size; // 缓存已存储数据的数量
    int capacity; // 缓存的最大容量
} LRUCache;

（2）LRU算法中的插入新数据操作的函数定义如下：

void LRUCachePut(LRUCache* cache, int key, int value);

函数的实现如下：

void LRUCachePut(LRUCache* cache, int key, int value) {
    CacheNode* node = (CacheNode*)malloc(sizeof(CacheNode)); // 创建新节点
    node->key = key;
    node->value = value;
    node->prev = NULL;
    node->next = NULL;

    if (cache->size == 0) { // 缓存为空
        cache->head = node;
        cache->tail = node;
        cache->size++;
    } else {
        CacheNode* p = cache->head;
        while (p != NULL) { // 遍历链表，查找是否已有该键的数据
            if (p->key == key) { // 已有该键的数据
                p->value = value; // 更新数据的值
                if (p == cache->head) { // 若该节点为头节点，则无需调整
                    return;
                } else if (p == cache->tail) { // 若该节点为尾节点，则将其移动到头部
                    cache->tail = p->prev;
                    cache->tail->next = NULL;
                    p->prev = NULL;
                    p->next = cache->head;
                    cache->head->prev = p;
                    cache->head = p;
                } else { // 该节点在链表中间，则将其移动到头部
                    p->prev->next = p->next;
                    p->next->prev = p->prev;
                    p->prev = NULL;
                    p->next = cache->head;
                    cache->head->prev = p;
                    cache->head = p;
                }
                return;
            }
            p = p->next;
        }

        if (cache->size < cache->capacity) { // 缓存未满，直接插入新节点到头部
            node->next = cache->head;
            cache->head->prev = node;
            cache->head = node;
            cache->size++;
        } else { // 缓存已满，删除尾部的节点，再将新节点插入到头部
            CacheNode* q = cache->tail;
            cache->tail = q->prev;
            cache->tail->next = NULL;
            free(q);
            node->next = cache->head;
            cache->head->prev = node;
            cache->head = node;
        }
    }
}

该函数的实现思路是：先遍历链表，查找是否已有该键的数据，若有，则更新数据的值，并将该节点移动到链表头部；若没有，则插入新节点到链表头部。若缓存已满，则删除链表尾部的节点。最后需要注意：插入新节点时，需要将其插入到链表头部；删除尾部节点时，需要释放其内存空间。