双向LRU链表

最新推荐文章于 2024-02-14 13:09:00 发布
最新推荐文章于 2024-02-14 13:09:00 发布
阅读量2.9k 收藏 3
点赞数
分类专栏： 算法与程序设计 文章标签： list table delete null struct 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foudary/article/details/6582885
版权
LRU是最近最少使用算法。一般内存管理的时候采用LRU算法可以提高性能。

将cache缓存块位置用LRU双向链表链接起来，将新加入的块直接放到链表的头，当一个块被命中后，把该块调整到链表的头，这样经过多次操作之后，最近被命中过的块就会向链表头部移动，而没有被命中的内容会向链表尾部移动，需要替换时，就直接从链表尾部替换即可。新的内容直接插入链表头部，这样就实现了LRU的思想。

算法中维护了一个freelist，用于管理空闲块的位置，每次需要插入新的内容时，就从freelist里面获取一个空闲块，将新内容复制，然后插入到链表头部；删除时就从链表尾部删除结点，然后更新到freelist里；查找一个结点时，在一般链表中的时间复杂度是O(n)，为了提高查找效率，在算法中加入了一个hash表，每次新加入的结点都会更新到hash表里，删除结点时会从hash表中移除，这样查找的时候直接从hash表里查询，获取结点的位置，从而时间复杂度为O(1)。

C语言实现的代码如下（已经测试通过了）：

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
#define LRU_SIZE 20
#define HASH_BASE 20
#define LRU_SUCCESS 0
#define LRU_ERROR  -1
#define LRU_MISS 0
#define LRU_HIT 1
#define LRU_HASH_KEY(_key,_base)               (int)(((int)_key)%(_base))
 
typedef struct _LRU_NODE{
         int id;
         int key;
         int free;
         int prev;
         int next;
}LRU_NODE,*PLRU_NODE;
typedef struct _LRU_HASH{
    unsigned long   basesize;
    int base[HASH_BASE];
}LRU_HASH,*PLRU_HASH;
 
typedef struct _LRU_LIST{
         int capacity;
         int usage;
         LRU_NODE bucket[LRU_SIZE];
         int freelist;
         int head;
         int tail;
         LRU_HASH hash;
}LRU_LIST,*PLRU_LIST;
 
int lru_init(PLRU_LIST list, int capacity, int hashbase)
{
         int i;
         PLRU_NODE node;
         list->capacity = capacity;
         list->usage = 0;
         list->head = -1;
         list->tail = -1;
         list->freelist = -1;
         for(i = capacity - 1; i >= 0; i--)
         {
                   list->bucket[i].id = i;
                   list->bucket[i].key = -1;
                   list->bucket[i].free = 1;
                   list->bucket[i].prev = -1;
                   list->bucket[i].next = -1;
                   if(list->freelist == -1)
                   {
                            list->freelist = list->bucket[i].id;
                   }
                   else
                   {
                            node = &(list->bucket[list->freelist]);
                            node->prev = list->bucket[i].id;
                            list->bucket[i].next = node->id;
                            list->freelist = list->bucket[i].id;
                   }
         }
         for(i = 0; i < hashbase; i++)
         {
                   list->hash.base[i] = -1;
         }
         list->hash.basesize = hashbase;
         return LRU_SUCCESS;
}
int lru_sethead(PLRU_LIST list, PLRU_NODE node)
{
         PLRU_NODE tempnode;
         if(node->free)
                   return LRU_SUCCESS;
         if(node->id == list->head)
                   return LRU_SUCCESS;
         if(list->head == -1)
         {
                   //应该不会到这里面来 
                   list->head = node->id;
                   list->tail = node->id;
                   node->prev = -1;
                   node->next = -1;
         }
         else
         {
                   if(list->tail == node->id)
                   {
                            list->tail = node->prev;
                            tempnode = &(list->bucket[list->tail]);
                            tempnode->next = -1;
                            
                   }
                   else 
                   {
                            tempnode = &(list->bucket[node->prev]);
                            tempnode->next = node->next;
                            tempnode = &(list->bucket[node->next]);
                            tempnode->prev = node->prev;
                   }
                   tempnode = &(list->bucket[list->head]);
                   tempnode->prev = node->id;
                   node->next = list->head;
                   node->prev = -1;
                   list->head = node->id;
         }
         return LRU_SUCCESS;
}
int lru_getfree(PLRU_LIST list, PLRU_NODE *freenode)
{
         PLRU_NODE node = NULL;
         if(list->freelist != -1)
         {
                   node = &(list->bucket[list->freelist]);
                   list->freelist = node->next;
                   if(list->freelist != -1)
                   {
                            list->bucket[list->freelist].prev = -1;
                   }
                   node->free = 1;
                   *freenode = node;
                   return LRU_SUCCESS;
         }
         else
         {
                   *freenode = NULL;
                   return LRU_ERROR;
         }
}
/*lru_delete:delete tail lru node
list:lru list
*/
int lru_delete(PLRU_LIST list)
{
         PLRU_NODE tempnode;
         int hashkey;
         if(list->tail == -1)
                   return LRU_ERROR;
         tempnode = &(list->bucket[list->tail]);
         list->tail = tempnode->prev;
         if(list->tail != -1)
                   list->bucket[list->tail].next = -1;
         else
                   list->head = -1;
 
         //删除hash结点
         hashkey = LRU_HASH_KEY(tempnode->key, list->hash.basesize);
         list->hash.base[hashkey] = -1;
         
         if(list->freelist != -1)
         {
                   tempnode->next = list->freelist;
                   list->bucket[list->freelist].prev = tempnode->id;
                   list->freelist = tempnode->id;
                   tempnode->prev = -1;
                   tempnode->free = 1;
                   tempnode->key = -1;
         }
         else
         {
                   list->freelist = tempnode->id;
                   tempnode->key = -1;
                   tempnode->free = 1;
                   tempnode->prev = -1;
                   tempnode->next = -1;
         }
         list->usage--;
         return LRU_SUCCESS;
}
int lru_insert(PLRU_LIST list, PLRU_NODE node)
{
         //对于list满的情况和插入有相同key的node
         //在函数调用之前作判断
         PLRU_NODE tempnode;
         int key;
         int hashkey;
         //插入lru hash表
         key = node->key;
         hashkey = LRU_HASH_KEY(key, list->hash.basesize);
         list->hash.base[hashkey] = node->id;
         
         if(list->head == -1)
         {
                   list->head = node->id;
                   list->tail = node->id;
                   node->prev = -1;
                   node->next = -1;
         }
         else
         {
                   tempnode = &(list->bucket[list->head]);
                   node->next = list->head;
                   tempnode->prev = node->id;
                   list->head = node->id;
                   node->prev = -1;
         }
         node->free = 0;
         list->usage++;
         return LRU_SUCCESS;
}
int lru_inquiry(PLRU_LIST list, int key)
{
         PLRU_NODE tempnode;
         int hashkey;
         if(list->head == -1)
                   return LRU_MISS;
 
         hashkey = LRU_HASH_KEY(key, list->hash.basesize);
         if(list->hash.base[hashkey] == -1)
                   return LRU_MISS;
         else
         {
                   tempnode = &(list->bucket[list->hash.base[hashkey]]);
         }
         //没加lru hash表之前的查询方式
         /*tempnode = &(list->bucket[list->head]);
         while(tempnode && tempnode->key != key)
         {
                   if(tempnode->next == -1)
                            tempnode = NULL;
                   else
                            tempnode = &(list->bucket[tempnode->next]);
         }
         if(!tempnode)
                   return LRU_MISS;*/
         lru_sethead(list,tempnode);
         return LRU_HIT;
}
int lru_show(PLRU_LIST list)
{
         PLRU_NODE node;
         if(list->head == -1)
         {
                   printf("list is empty!\n");
                   return LRU_ERROR;
         }
         node = &(list->bucket[list->head]);
         while(node)
         {
                   printf("id:%d,key:%d\n", node->id, node->key);
                   if(node->next == -1)
                            node = NULL;
                   else
                            node = &(list->bucket[node->next]);
         }
         return LRU_SUCCESS;
}
int lru_clear(PLRU_LIST list)
{
         PLRU_NODE tempnode,node;
         unsigned long j;
         if(list->head == -1)
                   return LRU_SUCCESS;
         tempnode = &(list->bucket[list->head]);
         while(tempnode)
         {
                   if(tempnode->next == -1)
                            node = NULL;
                   else
                            node = &(list->bucket[tempnode->next]);
                   if(list->freelist == -1)
                   {
                            list->freelist = tempnode->id;
                            tempnode->free = 1;
                            tempnode->key = -1;
                            tempnode->next = -1;
                            tempnode->prev = -1;
                   }
                   else
                   {
                            tempnode->next = list->freelist;
                            list->bucket[list->freelist].prev = tempnode->id;
                            list->freelist = tempnode->id;
                            tempnode->prev = -1;
                            tempnode->key = -1;
                            tempnode->free = 1;
                   }
                   tempnode = node;
         }
         for(j = 0; j < list->hash.basesize; j++)
         {
                   list->hash.base[j] = -1;
         }
         list->head = -1;
         list->tail = -1;
         list->usage = 0;
         return LRU_SUCCESS; 
}
 
void main()
{
         int key_table[LRU_SIZE];
         int i, usage;
         PLRU_LIST list;
         PLRU_NODE node;
         srand(time(NULL));
         for(i = 0; i < LRU_SIZE; i++)
         {
                   key_table[i] = rand() % LRU_SIZE;
                   printf("key_table[%d]:%d\n", i, key_table[i]);
         }
         list = (PLRU_LIST)malloc(sizeof(LRU_LIST));
         if(!list)
                   printf("malloc error!\n");
         lru_init(list, LRU_SIZE, HASH_BASE);
         //node = (PLRU_NODE)malloc(sizeof(LRU_NODE));
         //if(!node)
                   //printf("malloc error!\n");
         for(i = 0; i < LRU_SIZE; i++)
         {
                   if(LRU_MISS == lru_inquiry(list, key_table[i]))
                   {
                   if(LRU_SUCCESS == lru_getfree(list, &node))
                   {
                            node->key =key_table[i];
                            lru_insert(list, node);
                   }
                   else
                   {
                            printf("lru_getfree:get no free node!\n");
                   }
                   }
                   else
                   {
                            printf("***************\n");
                            printf("lru_inquiry hit key_table[%d]:%d\n", i, key_table[i]);
                            lru_show(list);
                   }
         }
         lru_show(list);
         usage = list->usage;
         for(i = 0; i < usage; i++)
         {
                   lru_delete(list);
                   printf("after delete one node!\n");
                   lru_show(list);
         }
         lru_clear(list);
}
penyunwudong
关注
专栏目录
LRU链表介绍
daha1314的博客
05-07 1699
文章目录 1. 简介 2. LRU 组织 2.1 LRU 链表 2.2 LRU Cache 2.3 LRU 移动操作 2.3.1 page 加入 LRU 2.3.2 其他 LRU 移动操作 3. LRU 回收 3.1 LRU 更新 3.2 Swappiness 3.3 反向映射 3.4 代码实现 3.4.1 struct scan_control 3.4.2 shrink_node() 3.4.3 shrink_list(
LRU算法 C++实现（HashMap+双向链表）
weixin_45590210的博客
01-22 861
leetcode上测试代码的题目 LRU（最近最少使用算法），是缺页置换解决方法中的一种。时间复杂度优秀O（1），空间复杂度不算哈希表本身的消耗的话还会多出维护双向链表左右指针的2N大小的空间消耗。 具体实现方法就是在原有数据结构（一般是哈希表）的基础上套上一个双向链表。当操作（询问，修改，增加）某个链表中某个元素的时候把这个元素移动到链表头上。当缓存区满了的时候去掉链表尾上的那个元素即可。 代码实现（HashSet和双向链表都是自实现的）： class LRUCache { public: sta
看动画理解「链表」实现LRU缓存淘汰算法
weixin_33829657的博客
12-24 344
前几节学习了「链表」、「时间与空间复杂度」的概念，本节将结合「循环链表」、「双向链表」与 「用空间换时间的设计思想」来设计一个很有意思的缓存淘汰策略：LRU缓存淘汰算法。 循环链表的概念 如上图所示：单链表的尾结点指针指向空地址，表示这就是最后的结点了。而循环链表的尾结点指针是指向链表的头结点。 因此**循环链表是一种特殊的单链表。**它跟单链表唯一的区别就在于尾结点。它像一个环一样首尾相连，所...
采用双向链表手动实现LRU算法
nandao158的博客
04-07 808
采用双向链表手动实现LRU算法， redis有一种淘汰算法LRU策略，今天我们采用java语言双向链表分享一下： 1、leetcode描述； /** * * 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void pu..
Mysql——LRU链表
小志的博客
11-02 2027
目录一、LRU链表的概述二、LRU链表的处理逻辑三、LRU链表的优缺点四、预读的概述五、预读的分类（根据触发方式分类）六、造成Buffer Pool命中率低的原因七、Buffer Pool命中率低的解决方式八、对于简单LRU链表的缺点优化 一、LRU链表的概述 LRU = Least Recently Used（最近最少使用）； 由于缓冲区空间有限，如果满了，则需要把旧的移除掉，新的加进来； 把使用频繁的数据保留在缓存中，把使用频率低的数据移除； 用来记录缓冲页的被使用热度； Buffer Pool的缓冲
浅析MySQL的lru链表
01-19
一、简述传统的LRU链表 LRU：Least Recently Used 相信大家对LRU链表是不陌生的，它...其实所谓的LRU链表本质上就是一个双向循环链表，如下图： 下面我们结合LRU链表和数据页机制描述一下MySQL加载数据的机制： 我们将
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
双向链表和双向循环链表在JavaScript中的应用广泛，例如在实现高效的LRU缓存策略、模拟DOM事件冒泡机制等方面都有重要作用。理解并掌握这些数据结构的实现原理，有助于提升JavaScript编程能力，优化算法效率，解决...
带头结点的双向循环链表
07-17
双向循环链表是一种高级的数据结构，常用于需要前后移动指针的场景，如实现LRU缓存淘汰策略、编辑器的撤销重做功能等。本项目以C++语言实现了带头结点的双向循环链表，这将有助于我们深入理解这一概念。 首先，双向...
创建双向链表_双向链表_
09-30
在实际编程中，双向链表常用于实现高效的缓存、队列、堆栈等数据结构，以及某些高级算法，如LRU（Least Recently Used）页面替换算法。由于其灵活的插入和删除操作，双向链表在需要频繁进行这些操作的场景下特别有用...
单链表LRU
weixin_34396103的博客
04-05 153
单链表实现lru 越靠近链表尾部的节点是越早之前访问的 当有一个新的数据被访问时，从链表头开始顺序遍历链表 1.如果此数据之前已经被缓存在链表中 遍历得到这个数据对应的节点，并将其从原来的位置删除，然后再插入到链表的头部 2.没在缓存链表里 2.1 缓存未满，将次节点直接插入到链表的头部 2.2 已经满了，删除链表尾部节点，将新的数据节点插入到链表的头部 single_list_l...
双向链表实现LRU（最近最少使用）
weixin_42381171的博客
05-13 143
public class LRUCache { class DLinkedNode { int key; int value; DLinkedNode prev; DLinkedNode next; public DLinkedNode() {} public DLinkedNode(int _key, int _value) {key = _key; value = _value;} }
LeetCode之LRU缓存机制
shihao的博客
05-25 435
LRU缓存机制 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制。它应该支持以下操作： 获取数据 get 和 写入数据 put 。 获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。 写入数据 put(key, value) - 如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。 进阶: 你是否.
理解双向链表的优势:利用双向链表实现LRU算法
qq_45512097的博客
07-13 596
由于LRU算法的特性，需要不断的对链表进行添加以及移位的操作(添加新入元素，移位:最近访问的元素加到链表头，最近访问的元素要移动到链表尾)，所以。所以用双向链表的优势，可以只用一个head头节点就可以用O(1)复杂度查找到链表头与链表尾的位置。接下来从新建LRU链表，添加元素， 移位元素(即最近访问的元素移位)来介绍此算法。
LRU 双向链表+哈希表 python
weixin_39544046的博客
01-24 231
通过双向链表和哈希表的结合实现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
双向链表结构衍生出来的LRU缓存（来自leetcode题目）
四问四不知的博客
09-07 422
import java.util.HashMap; /* Design and implement a data structure for Least Recently Used (LRU) cache. It should support the following operations: get and put. get(key) - Get the value (will alway...
双链表实现LRU算法
恋恋风辰的技术博客
12-30 1127
链表 所谓链表就是一个节点指向另一个节点的数据结构，像一条链子把每个节点连接起来。 如果一个节点既指向了后面的节点，也指向了前面的节点，这些节点就构成了双向链表。 我们先定义这个节点结构 class NodeLRU { public: NodeLRU(int v) : val(v), prev(nullptr), next(nullptr) {} int val; NodeLRU *prev; NodeLRU *next; }; val为节点的数据域表示节点存储的数值 p
14.1 LRU链表
Do one thing at a time, and do well.
07-19 1270
在最近几十年操作系统的发展过程中，有很多页面交换算法，其中每个算法都有各自的优点和缺点。linux内核中采用的页面交换算法主要是LRU算法和第二次机会法(second chance)。 LRU链表 LRU是leastrecentlyused（最近最少使用）的缩写，LRU假定最近不使用的页在较短的时间内也不会频繁使用。在内存不足时，这些页面将成为被换出的候选者。内核使用双向链表来定义LRU链表，并且根据页面的类型分为LRU_ANON和LRU_FILE。每种类型根据页面的活跃分为活跃L...
【链表】-Lc146-实现LRU（双向循环链表）
最新发布
记忆、理解、表达和融会贯通。
02-14 1332
运用你所掌握的数据结构，设计和实现一个 LRU (Least Recently Used， 最近最少使用) 缓存机制，本篇文章为双向循环链表的实现方式。
双向链表实现与频度操作
双向链表的应用场景广泛，例如在实现LRU缓存淘汰策略、编辑距离算法等复杂数据操作时，其灵活的插入和删除操作能提供便利。在这个实现中，`freq`字段的引入可以用于统计元素出现的次数，这对于某些需要统计信息的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值