lru 双向链表+哈希

最新推荐文章于 2022-07-12 11:11:52 发布
最新推荐文章于 2022-07-12 11:11:52 发布
阅读量373 收藏 1
点赞数
分类专栏： 数据结构
原文链接：https://www.cnblogs.com/wanghao-boke/p/12162157.html
版权 
/*
LRUCacheImpl.c
*/
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include"LRUCache.h"
#include"LRUCacheImpl.h"

typedef struct cacheEntryS
{
    char key;
    char data;

    struct cacheEntryS *hashListPrev;   /* 缓存哈希表指针，指向哈希链表的前一个元素 */
    struct cacheEntryS *hashListNext;   /* 缓存哈希表指针，指向哈希链表的后一个元素 */

    struct cacheEntryS *lruListPrev;    /* 缓存双向链表，指向双向链表的前一个元素 */
    struct cacheEntryS *lruListNext;    /* 缓存双向链表，指向双向链表的后一个元素 */
}cacheEntryS;

typedef struct LRUCacheS
{
    int cacheCapacity;
    cacheEntryS **hashMap;  //缓存的hash表

    cacheEntryS *lruListHead;   //缓存双向链表的表头
    cacheEntryS *lruListTail;   //缓存双向链表表位
    int lruListSize;            //缓存双向链表节点个数
}LRUCacheS;


static void freeList(LRUCacheS *cache);

/****************************************************
*LRU缓存及缓存单位相关接口及实现
*****************************************************/

//创建一个缓存单位
static cacheEntryS *newCacheEntry(char key, char data)
{
    cacheEntryS* entry = NULL;
    if (NULL == (entry = malloc(sizeof(*entry))))
    {
        perror("malloc");
        return NULL;
    }

    memset(entry, 0, sizeof(*entry));
    entry->key = key;
    entry->data = data;
    return entry;
}

//释放一个缓存单元
static void freeCacheEntry(cacheEntryS* entry)
{
    if (NULL == entry)
    {
        return ;
    }
    free(entry);
}

//创建一个LRU缓存
int LRUCacheCreate(int capacity, void **lruCache)
{
    LRUCacheS* cache = NULL;
    if (NULL == (cache = malloc(sizeof(*cache))))
    {
        perror("malloc");
        return -1;
    }

    memset(cache, 0, sizeof(*cache));
    cache->cacheCapacity = capacity;
    cache->hashMap = (cacheEntryS**)malloc(sizeof(cacheEntryS)*capacity);
    if (NULL == cache->hashMap)
    {
        free(cache);
        perror("malloc");
        return -1;
    }

    memset(cache->hashMap, 0, sizeof(cacheEntryS)*capacity);
    *lruCache = cache;
    return 0;
}

//释放一个LRU缓存
int LRUCacheDestroy(void *lruCache)
{
    LRUCacheS* cache = (LRUCacheS*)lruCache;
    if (NULL == cache)
    {
        return 0;
    }

    if (cache->hashMap)
    {
        free(cache->hashMap);
    }

    freeList(cache);
    free(cache);
    return 0;
}

/****************************************************
* 双向链表相关接口及实现
*****************************************************/

//从双向链表中删除指定节点
static void removeFromList(LRUCacheS *cache, cacheEntryS* entry)
{
    //链表为空
    if (cache->lruListSize == 0)
    {
        return;
    }

    if (entry == cache->lruListHead && entry == cache->lruListTail)
    {
        //当链表仅剩当前一个节点
        cache->lruListTail = cache->lruListHead = NULL;
    }
    else if (entry == cache->lruListHead)
    {
        //删除节点位于表头
        cache->lruListHead = entry->lruListNext;
        cache->lruListHead->lruListPrev = NULL;
    }
    else if (entry == cache->lruListTail)
    {
        //删除节点位于表尾
        cache->lruListTail = entry->lruListPrev;
        cache->lruListTail->lruListNext = NULL;
    }
    else
    {
        //非头非为情况，直接摘抄节点
        entry->lruListPrev->lruListNext = entry->lruListNext;
        entry->lruListNext->lruListPrev = entry->lruListPrev;
    }

    //
    cache->lruListSize--;
}

//见节点插入链表表头
static cacheEntryS *insertToListHead(LRUCacheS *cache, cacheEntryS* entry)
{
    cacheEntryS *removeEntry = NULL;
    if (++cache->lruListSize > cache->cacheCapacity)
    {
        /* 如果缓存满了，即链表当前节点数已等于缓存容量，那么需要先删除链表表尾节点，即淘汰最久没有被访问到的缓存数据单元*/
        removeEntry = cache->lruListTail;
        removeFromList(cache, cache->lruListTail);
    }

    if (cache->lruListHead == NULL && cache->lruListTail == NULL)
    {
        //如果当前俩目标为空链表
        cache->lruListHead = cache->lruListTail = entry;
    }
    else
    {
        //当前链表非空，插入表头
        entry->lruListNext = cache->lruListHead;
        entry->lruListPrev = NULL;
        cache->lruListHead->lruListPrev = entry;
        cache->lruListHead = entry;
    }
    return removeEntry;
}

//释放整个链表
static void freeList(LRUCacheS *cache)
{
    //链表为空
    if (0 == cache->lruListSize)
    {
        return;
    }
    cacheEntryS* entry = cache->lruListHead;
    while(entry)
    {
        cacheEntryS *temp = entry->lruListNext;
        freeCacheEntry(entry);
        entry = temp;
    }

    cache->lruListSize = 0;
}


//辅助性接口，用于保证最近访问的节点总是位于链表表头
static void updateLRUList(LRUCacheS *cache, cacheEntryS *entry)
{
    //摘抄节点
    removeFromList(cache, entry);
    //将节点插入到链表表头
    insertToListHead(cache, entry);
}

/****************************************************
* hash表相关接口及实现
*****************************************************/

//哈希函数
static int hashKey(LRUCacheS *cache, char key)
{
    return (int)key%cache->cacheCapacity;
}

//从哈希表中获取缓存单元
static cacheEntryS *getValueFromHashMap(LRUCacheS *cache, char key)
{
    //使用函数定位数据存放在哪个槽中
    cacheEntryS *entry = cache->hashMap[hashKey(cache,key)];

    //遍历槽内链表，找到准确的数据项
    while(entry)
    {
        if (entry->key == key)
        {
            break;
        }
        entry = entry->hashListNext;
    }

    return entry;
}


//向hash表中插入缓存单元
static void insertentryToHashMap(LRUCacheS *cache, cacheEntryS *entry)
{
    //使用函数定位数据存放在哪个槽中
    cacheEntryS *n = cache->hashMap[hashKey(cache, entry->key)];
    if (n != NULL)
    {
        //如果槽内已经有其他数据项，将巢内数据项与当前预加入数据项组成链表
        //当前预加入数据项为表头
        entry->hashListNext = n;
        n->hashListPrev = entry;
    }

    //将数据项放到到哈希槽内
    cache->hashMap[hashKey(cache, entry->key)] = entry;
}


//从哈希表中删除缓存单元
static void removeEntryFromHashMap(LRUCacheS *cache, cacheEntryS *entry)
{
    //无需做任何删除操作的情况
    if (NULL == entry || NULL == cache || NULL == cache->hashMap)
    {
        return ;
    }

    //定位数据位于哪个槽内
    cacheEntryS *n = cache->hashMap[hashKey(cache, entry->key)];
    //遍历槽内链表，找到与删除节点，将节点从哈希表摘除
    while(n)
    {
        //找到预删除节点，将节点从hash表摘除
        if (n->key == entry->key)
        {
            if (n->hashListPrev)
            {
                n->hashListPrev->hashListNext = n->hashListNext;
            }
            else
            {
                cache->hashMap[hashKey(cache, entry->key)] = n->hashListNext;
            }

            if (n->hashListNext)
            {
                n->hashListNext->hashListPrev = n->hashListPrev;
            }
        }

        n = n->hashListNext;
    }
}


/****************************************************
* hash表相关接口及实现
*****************************************************/

//将数据放入LRU缓存中
int LRUCacheSet(void *lrucache, char key, char data)
{
    LRUCacheS *cache = (LRUCacheS *)lrucache;
    //从hash表查找数据是否已经在缓存中
    cacheEntryS* entry = getValueFromHashMap(cache, key);
    if (NULL != entry)
    {
        //更新数据，将数据项更新至链表表头
        entry->data = data;
        updateLRUList(cache, entry);
    }
    else    //数据没在缓存中，新建缓存插入链表表头
    {
        entry = newCacheEntry(key, data);
        cacheEntryS *removeEntry = insertToListHead(cache, entry);
        if (NULL != removeEntry)
        {
            //缓存满，淘汰最近最久没有被访问到的数据单元
            removeEntryFromHashMap(cache, removeEntry);
            freeCacheEntry(removeEntry);
        }
        insertentryToHashMap(cache, entry);
    }
    return 0;
}

char LRUCacheGet(void *lruCache, char key)
{
    LRUCacheS *cache = (LRUCacheS *)lruCache;
    cacheEntryS *entry = getValueFromHashMap(cache, key);
    //检查hash缓存是否已经存在数据
    if (NULL != entry)
    {
        //缓存中存在数据，更新至表头
        updateLRUList(cache, entry);
        return entry->data;
    }
    else
    {
        return '\0';
    }

}

void LRUCachePrint(void *lruCache)
{
    LRUCacheS *cache = (LRUCacheS *)lruCache;
    if (NULL == cache || 0 == cache->lruListSize)
    {
        return;
    }

    fprintf(stdout, "\n>>>>>>>>>>>>>>\n");
    fprintf(stdout, "cache (key data):\n");
    cacheEntryS *entry = cache->lruListHead;

    while(entry)
    {
        fprintf(stdout, "(%c, %c) ", entry->key, entry->data);
        entry = entry->lruListNext;
    }
    fprintf(stdout, "\n<<<<<<<<<<<<<<<<<<\n\n");
}

 

dachunfree
关注
专栏目录
LRU 缓存机制实现：哈希表 + 双向链表
AI天才研究院
03-21 8784
算法详解LRU 缓存机制可以通过哈希表辅以双向链表实现，我们用一个哈希表和一个双向链表维护所有在缓存中的键值对。双向链表按照被使用的顺序存储了这些键值对，靠近头部的键值对是最近使用的，而靠近尾部的键值对是最久未使用的。哈希表即为普通的哈希映射(HashMap)，通过缓存数据的键映射到其在双向链表中的位置。这样以来，我们首先使用哈希表进行定位，找出缓存项在双向链表中的位置，随后将其移动到双向链表的头...
LRU算法 C++实现（HashMap+双向链表）
weixin_45590210的博客
01-22 843
leetcode上测试代码的题目 LRU（最近最少使用算法），是缺页置换解决方法中的一种。时间复杂度优秀O（1），空间复杂度不算哈希表本身的消耗的话还会多出维护双向链表左右指针的2N大小的空间消耗。 具体实现方法就是在原有数据结构（一般是哈希表）的基础上套上一个双向链表。当操作（询问，修改，增加）某个链表中某个元素的时候把这个元素移动到链表头上。当缓存区满了的时候去掉链表尾上的那个元素即可。 代码实现（HashSet和双向链表都是自实现的）： class LRUCache { public: sta
LeetCode-[哈希链表/LRU算法]-LRU缓存机制
jswrcsdn1的博客
01-17 413
1. LRU算法是什么？ 1.1. LRU算法是一种按时间先后的缓存淘汰策略。 比如手机后台可以同时开的程序为3个，则当你打开第四个时，按照lru策略，最早被打开的程序被认为是“无用的”，它被淘汰。 这有点像队列，从队列头进，队列头一直是“最近”使用的应用。当队列满了，从队列尾删除。 值得一提的是：队列中的应用被使用后，它就变成“最近使用”了，应该提到队列头，在写代码时要注意这一点。 1.2. L...
LRU手写 双向链表+哈希
weixin_54110641的博客
02-19 404
1.我们首先想到快速查询 应该使用哈希表 可以做到快速查询 但是没有固定顺序 2.于是想到又固定顺序还要增加复杂度低 就应该用链表 但是删除做不到常数级别 最终选择双向链表 3.我们可以把双向链表和哈希表得键相映射可以取得联系 2.首先我们应该创建出来一个双向链表 struct Dlist{ int val; int key; Dlist* pre; Dlist* next; Dlist():val(0),key(0),pre(nullptr),nex...
LRU 双向链表+哈希表 python
weixin_39544046的博客
01-24 222
通过双向链表和哈希表的结合实现LRU class Node: def __init__(self, key = 0, value=0): self.key = key self.value = value self.next = None self.pre = None class Solution: def __init__(self, max_size = 0): self.dumm
LeetCode之LRU缓存机制
shihao的博客
05-25 426
LRU缓存机制 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 进阶: 你是否.
双向链表+HashMap 实现LRU算法（leetcode 416）
qq_34548229的博客
03-29 348
import java.util.HashMap; /** * @author MasterYee * @Description： * @date: 2020/3/29 */ public class LRUCache { class Node{ int key; int value; Node pre; Node...
【力扣刷题】146.LRU缓存——哈希表+双向链表
李小恩恩子的博客
07-12 446
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键
146. LRU Cache (双向链表+哈希表实现 LRU Cache)
Elo的博客
11-07 389
146. LRU Cache 题目大意: 设计并实现一个 LRU Cache. 实现对应的函数 get(key), put(key, value). Follow up: 所有操作 O(1) 时间复杂度. 实现 LRU Cache 的关键数据结构: 双向链表 + 哈希表. 以下实现中, 定义了双向链表结点类 Node. 以及 unordered_map<int, *Node> 类型的 ...
java之双向链表与哈希表实现LRU缓存机制
一名正在成长的程序员
10-27 730
背景 在研究双向队列之前，是遇到了这么一道题。 146. LRU缓存机制 这道题的思路是HashMap与双向队列的组合。LRU就是删除最近最少使用的数据值。 比如我先打开了支付宝，之后打开了手机淘宝，之后打开微信，此时在后台就是如下排列 之后我又点击支付宝，在后台中就会来到队友 假如缓存容量为3的话，此时又打开了时钟，就会把淘宝从缓存中删除，因为他是最近最少使用的应用。 那么这道题的思路很清...
leetcode面试题 16.25. LRU缓存
haoweng4800的博客
07-23 219
设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。 它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。写入数据 pu...
LeetCode-146. LRU Cache（双向链表 + 哈希表）
保持对编程的热情！
08-24 190
146.LRU Cache Medium 3402127FavoriteShare Design and implement a data structure forLeast Recently Used (LRU) cache. It should support the following operations:getandput. get(key)- Get the va...
C语言实现LRU缓存机制——哈希表+双向链表
weixin_42326997的博客
06-13 1867
题目描述 运用你所掌握的数据结构，设计和实现一个LRU（最近最少使用）缓存机制。它应该支持以下操作：获取数据get和写入数据 put。 获取数据get（key）-如果关键字（key）存在于缓存中，则获取关键字的值（总是正数），否则返回-1。 写入数据put（key，value）-如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组[关键字/值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 要求：时间复杂度为O（1）： 思路 1、一开始想的是用一
LRU的双链表的简单实现（小白写法）
隐身的六娃
04-08 328
先给一个节点类，属性有：节点值（我用的int类型数值为例），前节点，后节点。前节点主要功能是便于不用遍历的方式寻找前节点，以免多次遍历造成时间复杂度的增长。 public class Node { int value; Node next; Node pre; } 提供一个构造方法，去建立链表头 public Node(int value) { ...
146. LRU 缓存机制（链表+哈希表）
m0_37433111的博客
03-02 122
2021年3月2日 周二 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. 题目简介2. 题解参考文献 1. 题目简介 146. LRU 缓存机制 2. 题解 分析 LRU 的操作，要让 put 和 get 方法的时间复杂度为 O(1)，可以总结出 cache 这个数据结构必要的条件：查找快，插入快，删除快，有顺序之分。所以考虑链表(插入快，删除快，有顺序之分) + 哈希表(查找快)。 class LRUCache { private: int cap; list<p
循环双链表--LRU
weixin_52321645的博客
10-14 97
LRU ：最近最少使用，缓存淘汰法 #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #include<string.h> //链表中的每一个结点 typedef struct DoubleNode { struct DoubleNode* prve; struct DoubleNode* next; int data; }DNode; //定义链表总体 typedef struct L
双链表实现LRU算法
恋恋风辰的技术博客
12-30 1106
链表 所谓链表就是一个节点指向另一个节点的数据结构，像一条链子把每个节点连接起来。 如果一个节点既指向了后面的节点，也指向了前面的节点，这些节点就构成了双向链表。 我们先定义这个节点结构 class NodeLRU { public: NodeLRU(int v) : val(v), prev(nullptr), next(nullptr) {} int val; NodeLRU *prev; NodeLRU *next; }; val为节点的数据域表示节点存储的数值 p
LeetCode 146 LRU算法-hash+双链表、unorder_map
薛定谔的程序喵的博客
01-08 273
第二种解法：利用unordered_map本身进行匹配，实验表明，unordered_map是头插法，并且没有rbegin()迭代器，使用end()达不到想要的效果，所以每次删除数据冷的结点，需要遍历整个hash表，到第17个case通过不了。第一种解法：hash+双向链表。
[Leetcode] LRU Cache. 哈希表+双向链表之实现
枯树无花
01-09 413
题目 首先来看题目，就是实现一个LRU，最近最少使用。 Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and set. get(key) - Get the value (will always ...
java lru算法 链表
最新发布
09-06
在实现 LRU 算法时，我们通常使用一个双向链表和一个哈希表来存储数据。 链表中的每个节点用来存储一个数据，节点包含三个属性：key，value 和 prev、next 指针，其中 key 和 value 分别表示数据的键和值，prev 和 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值