lru算法

#include <stdio.h>

typedef struct cache_node{
        int key;
        int value;
        struct cachce_node *next;
        struct cache_node *prev;

}cache_node_t;

typedef struct lru_cache{
        struct cache_node head;
        struct cache_node tail;
        int list_size;
        int capability;
}lru_cache_t;

lru_cache_t * lru_cache_entry;

lru_cache_t * lru_cache_create(int capability){
        lru_cahe_t *lru_cache = NULL;
        lru_cache = malloc(sizeof(lru_cache_t);
        if(!lru_cache)
                return NULL;
        memset(lru_cache, 0, sizeof(lru_cache_t));
        lru_cache->capabilty = capability;
        lru_cache->list_size = 0;
        return lru_cache;

}

cache_node_t *cache_node_create(int key, int value){
        caech_node_t *cache_node = NULL;
        cache_node = malloc(sizeof(cache_node_t));
        if(!cache_node){
                return NULL;
        }

        cache_node->key = key;
        cache_node->value = value;

        return cache_node;
}

void cache_node_clean(cache_node_t *cache_node){
        if(!cache_node)
                return;
        free(cache_node);

}

int cache_node_insert(lru_cache_t *lru_cache, cache_node_t *cache_node){
        int rc = 0;
        cache_node_t * node_head = NULL;
        cache_node_t *node_tail = NULL;
        if(!lru_cache || !cache_node)
                return -1;

        if(lru_cache->list_size == 0){
                lru_cache->head.next = cache_node;
                lru_cache>head.prev = cache_node;

                cache_node->prev = &lru_cache->head;
                cache_node->next = &lrc_cache->head;

                lru_cache->list_size ++;
        }else if(lru_cache->list_size < lru_cache->capability){
                node_head = lru_cache->head.next;
                lru_cache->head.next = cache_node;
                cache_node->prev = &lru_cache->head;
                cache_node->next = node_head;
                node_head->prev = cache_node;

        lru_cache->list_size ++;
        }else{
                node_tail = lru_cache->head.prev;
                lru_cache->head.prev = node_tail->prev;
                node_tail->prev->next = &lru_cache->head;
                cache_node_clean(node_tail);
                node_tail = NULL;
                lru_cache->list_size--;
                cache_node_insert(lru_cache, cache_node);
        }

        return rc;
}

cache_node_t *cache_node_lookup(lru_cache_t * lru_cache ,int key){
        cache_node_t * cache_node = NULL;
        if(!lru_cache)
                return NULL;
        cache_node = lru_cache->next;
        while(cache_node != lru_cache){
                if(cache_node && cache_node->key == key)
                        goto find;
                cache_node = cache_node->next;
        }

        cache_node = NULL;
find:
        return cache_node;
}

void cache_node_del(lru_cache_t * lru_cache, int key){
        cache_node_t *cache_node = NULL;
        cache_node_t *cache_node_repv = NULL;
        cache_node_t * cache_node_next = NULL;
        cache_node = cacghe_node_lookup(lru_cache, key);
        if(!cache_node)
                return;
        cache_node_prev = cache_node->prev;
        cache_node_next = cache_node->next;
        cache_node_next->prev = cache_node_prev;
        cache_node_prev->next = cache_node_next;

        cache_node_clean(cache_node);
}

void cache_node_update(lru_cache_t *lru_cache, cache_node_t *cache_node){
        cache_node_del(lru_cache, cache_node);
        cache_node_insert(lru_cache, cache_node);
}

以上实现了简单的链表lru。缺少hash_map的管理。

如下增加hash_map实现

typedef struct cache_node{
        int key;
        int value;
        struct cachce_node *next;
        struct cache_node *prev;
		struct cache_node* map_next;
		struct cache_node* map_prev;
}cache_node_t;

typedef struct lru_cache{
        struct cache_node head;
        struct cache_node tail;
        int list_size;
        int capability;
        struct cache_node cache_map[capability];
}lru_cache_t;

int hash_code(int key, int cabability){
		return key%cabability;
}
再往下就是在insert的同时根据哈希函数往hash链表里填充缓存数据，解决冲突的办法是相同哈希函数计算值形成哈希链表。代码纯体力，不写了。