双向链表和哈希表的结合

于 2024-04-20 01:10:16 发布
阅读量854 收藏 8
点赞数 13
文章标签： 链表 散列表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/F445845/article/details/137982270
版权

432. 全 O(1) 的数据结构 - 力扣（LeetCode）

1.思路


讲述看到这一题的思路
这道题花了我大半时间研究出c++写法，如果用Java语言写的话比较好写，因为表示某些操作的时候足够方便，该思路中运用了set哈希表和双向链表，为什么会这么想呢？
首先本题要求时间复杂度均为O(1),考虑到链表的查找功能的时间复杂度为O(1),又联想到哈希表的增删操作的时间复杂度为O(1).


2.解题方法

把每次出现的字符串放在一个桶（set）中设置出现次数最小的头桶head,以及最大桶tail,那么可想而知求最终结果也就是在这中间找桶里面的字符，我们还需要一个哈希map,key记录字符串，value记录内存地址，注意这里c++的最大值为INT_MAX.
先额外设置一下插入操作insert和删除操作remove
insert()操作：
首先将cur节点的next节点指向pos节点，然后再将pos节点指向cur->next节点，
然后让cur节点和pos节点相互连接，中心思想就是把pos节点和当前cur节点的下一位互连再和当前节点cur互连。
remove()操作：
该操作可看做跳跃操作，就是将该节点的前后连起来即可，那么该节点也会自动失效，
inc()操作：
先判断key字符串是否在哈希表mp中，若不存在，可判断头桶的next桶的字符个数是否为1，若为1，则将字符串放入set中，若不存在，开辟一个字符个数为1的桶，再将其放入其中，
若该字符存在与哈希表mp中，先找到该字符对应的桶，分两种情况，若该桶后面的桶随对应的字符个数比该桶字符个数多一，则证明他们正好连续，则将mp中key的内存地址指向node->next，随后将key存入node—>next->set中，若不存在这样的桶，可在后面开辟一个这样大小字符个数的桶，newNode=new Node(key,node->val+1);随后删除该桶所对于set的key字符串，若该桶没有字符串了，直接将该桶删掉。
dec()操作：
同inc()操作的思路，稍微改动的就是先找到key对于的桶，判断该桶的val是否为1，若为1，mp直接删除key即可,若不为1，找node前面的桶的val是否为node->val-1,
然后分析方式同上，最后把该字符串从node->set表中删除，注意插入操作位set.insert(),删除操作为set.erase();然后判断该桶上面还有没有字符串，没有就删除该桶remove(node);
getMaxKey():
返回head->next所对应哈希表set的迭代器所对应的字符*(node->set.begin());
getMinKey():
返回tail->pre所对于哈希表set的迭代器所对应的字符*(node->set.bein());


3.复杂度：
 

复杂度
时间复杂度：所有操作均为 O(1)，这里将字符串长度视作常数。

空间复杂度：O(I)，其中 I是调用 inc 的次数。最坏情况下每次调用 inc传入的字符串均不相同，我们需要 O(I)大小的哈希表来存储所有字符串。


4.Code

我写了两种代码，不过思路一模一样，只是写法不同

struct Node{
	unordered_set<string>set;
	int val;
	Node *pre,*next;
	Node(string s,int c){
		pre=NULL;
		next=NULL;
		val=c;
		set.insert(s);
	}
};
class AllOne {
	
public:
	unordered_map<string,Node*>mp;
	Node* head;
	Node* tail;
    AllOne() {
        head=new Node("",0);
        tail=new Node("",INT_MAX);
        head->next=tail;
        tail->pre=head;
    }
    void inc(string key) {
         if(!mp.count(key)){
         	if(head->next->val==1){
         		mp[key]=head->next;
         		head->next->set.insert(key);
			 }
			 else{
			 	Node *newNode=new Node(key,1);
			 	mp[key]=newNode;
			 	insert(head,newNode);
			 }
		 }
		 else{
		 	Node *node=mp[key];
		 	if(node->next->val==node->val+1){
		 		mp[key]=node->next;
		 		node->next->set.insert(key);
			 }
			 else{
			 	Node *newNode=new Node(key,node->val+1);
			 	mp[key]=newNode;
			 	insert(node,newNode);
			 }
			 node->set.erase(key);
			 if(node->set.empty()){
			 	remove(node);
			 }
		 }
    }
    
    void dec(string key) {
       Node *node=mp[key];
       if(node->val==1){
       	mp.erase(key);
	   }
	   else{
	   	if(node->pre->val==node->val-1){
	   		mp[key]=node->pre;
	   		node->pre->set.insert(key);
		   }
		else{
			Node *newNode=new Node(key,node->val-1);
			mp[key]=newNode;
			insert(node->pre,newNode);
		}
	   }
	   node->set.erase(key);
	   if(node->set.empty()){
	   	remove(node);
	   }
    }
    void insert(Node* cur ,Node* pos){
    	 cur->next->pre=pos;
    	 pos->next=cur->next;
    	 cur->next=pos;
    	 pos->pre=cur;
	}
	void remove(Node* cur){
		 cur->pre->next=cur->next;
		 cur->next->pre=cur->pre;
	}
    
    string getMaxKey() {
      return *(tail->pre->set.begin());
    } 
    
    string getMinKey() {
      return *(head->next->set.begin());
    }
};

/**
 * Your AllOne object will be instantiated and called as such:
 * AllOne* obj = new AllOne();
 * obj->inc(key);
 * obj->dec(key);
 * string param_3 = obj->getMaxKey();
 * string param_4 = obj->getMinKey();
 */
struct Node{
    unordered_set<string> container;
    int val;
    Node* pre;
    Node* next;
    Node(string s){
        pre = NULL;
        next = NULL;
        val = 1;
        container.insert(s);
    }
};
class AllOne {
public:
    unordered_map<string,Node*> list;
    Node* head;
    Node* tail;
    /** Initialize your data structure here. */
    AllOne() {
        head = NULL;
        tail = NULL;
    }
    
    /** Inserts a new key <Key> with value 1. Or increments an existing key by 1. */
    void inc(string key) {
        if(list.count(key)){		//已存在
            Node* now = list[key];
            if(now == tail){		//在尾节点中
                if(now->container.size() == 1)  now->val += 1;		//可以直接修改val
                else{		//需要新建一个结点
                    Node* newTail = new Node(key);
                    newTail->val = now->val+1;
                    tail->next = newTail;
                    newTail->pre = tail;
                    tail = newTail;
                    now->container.erase(key);
                    list[key] = tail;
                }
            }else{
                if(now->next->val == now->val+1){		//后面挨着的结点，val+1
                    now->next->container.insert(key);
                    if(now->container.size() == 1){		//原来的结点只有1个元素，需要删除原来的结点
                        if(now == head){
                            now->next->pre = NULL;
                            head = now->next;
                        }else{
                            Node* prev = now->pre;
                            prev->next = now->next;
                            now->next->pre = prev;
                        }
                    }else{
                        now->container.erase(key);
                    }
                    list[key] = now->next;
                }else{		//后面挨着的不是val+1
                    if(now->container.size() == 1)  now->val += 1;		//可以直接修改val
                    else{		//新建一个结点
                        Node* newNode = new Node(key);
                        newNode->val = now->val+1;
                        newNode->next = now->next;
                        newNode->pre = now;
                        now->next->pre = newNode;
                        now->next = newNode;
                        now->container.erase(key);
                        list[key] = now->next;
                    }
                }
            }
        }else{		//没有出现
            if(head==NULL){		//空链表，直接建立结点
                head = new Node(key);
                tail = head;
            }else{
                if(head->val == 1)  head->container.insert(key);		//头节点val=1，直接插入即可
                else{		//建立新的头节点
                    Node* newHead = new Node(key);	
                    newHead->next = head;
                    head->pre = newHead;
                    head = newHead;
                }
            }
            list[key] = head;
        }
    }
    
    /** Decrements an existing key by 1. If Key's value is 1, remove it from the data structure. */
    void dec(string key) {
        if(list.count(key)){		
            Node* now = list[key];
            if(now->val == 1){		//发生在头结点上
                if(now->container.size() == 1){		//只有这一个元素，需要删除结点
                    if(tail == head){		//只有这一个结点，删除后，链表为空
                        head = NULL;
                        tail = head;
                    }else{
                        head = head->next;
                    }
                }else{
                    now->container.erase(key);
                }
                list.erase(key);
            }else if(now == head){		//发生在头节点上
                if(now->container.size() == 1)  now->val-=1;		//可以直接修改val
                else{		//需要新建一个头节点
                    Node* newHead = new Node(key);
                    newHead->val = now->val-1;
                    head->pre = newHead;
                    newHead->next = head;
                    head = newHead;
                    now->container.erase(key);
                    list[key] = head;
                }
            }else{		//发生在其他结点上
                if(now->pre->val == now->val-1){		//前面紧挨着的结点，val-1
                    now->pre->container.insert(key);
                    if(now->container.size() == 1){		//原结点只有一个元素，需要删除原结点
                        Node* prev = now->pre;
                        prev->next = now->next;
                        if(now!=tail) now->next->pre = prev;
                        else tail = prev;
                    }else{
                        now->container.erase(key);
                    }
                    list[key] = now->pre;
                }else{		//前面挨着的结点，不是val-1
                    if(now->container.size() == 1)  now->val -= 1;	//只有一个元素，可以直接修改val		
                    else{		//建立一个新的结点
                        Node* newNode = new Node(key);
                        newNode->val = now->val-1;
                        newNode->next = now;
                        newNode->pre = now->pre;
                        now->pre->next = newNode;
                        now->pre = newNode;
                        now->container.erase(key);
                        list[key] = now->pre;
                    }
                }
            }
        }
    }
    
    /** Returns one of the keys with maximal value. */
    string getMaxKey() {
        if(tail == NULL)    return "";
        return *(tail->container.begin());
    }
    
    /** Returns one of the keys with Minimal value. */
    string getMinKey() {
        if(head == NULL)    return "";
        return *(head->container.begin());
    }
};

/**
 * Your AllOne object will be instantiated and called as such:
 * AllOne* obj = new AllOne();
 * obj->inc(key);
 * obj->dec(key);
 * string param_3 = obj->getMaxKey();
 * string param_4 = obj->getMinKey();
 */
阿尼亚不服码
关注
【力扣刷题】146.LRU缓存——哈希表+双向链表
李小恩恩子的博客
07-12 432
请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作导致关键
实现链表与哈希表相结合的快速表
且听风吟的博客
09-09 1461
设计可以变更的缓存结构：该结构在构造时确定大小，假设长度 len，且有两个功能： int set（string key，int value）：将记录（key，value）插入该结构 int get（string key）：返回key对应的value 要求： set和get时间复杂度为O(1) 某个key的set/get操作一旦发生，认为这个key成为最常使用的（默认这一步也是O(1) ） 当缓存大小超过k时，移除最不常用的记录。 思路： 第1点，set 和 get 的时间复杂度要为O(1)，数组虽然
双向链表与hash表
11-29
从linux内核提取出来的，双向链表和hash表实现。在普通的用户态C程序中，均可使用
Java实现LRU算法（哈希表加双向链表）
zhangyuanshuai的博客
05-26 380
LRU LRU 全称 Least Recently Used，意为最近最少使用，是最常见的页面置换算法，也常用于实现缓存淘汰策略。 实现 哈希表 + 双向链表。链表头节点代表最近使用过的数据。 对于 get 操作，首先判断 key 是否存在： 如果 key 不存在，则返回 -1； 如果 key 存在，则 key 对应的节点是最近被使用的节点。通过哈希表定位到该节点在双向链表中的位置，并将其移动到双向链表的头部，最后返回该节点的值。 对于 put 操作，首先判断 key 是否存在： 如果 ke
Leetcode-哈希表+双向链表-146. LRU 缓存机制
一只菜鸟夹
03-05 126
题目146. LRU 缓存机制： 题解： 代码： struct Node { int key; int val; Node* pre; Node* next; Node(){val = 0; pre = nullptr; next = nullptr;} Node(int k,int v){key = k; val = v; pre = nullptr; next = nullptr;} };
哈希表（数组+链表）
sinat_31089473的博客
08-10 2003
散列表（Hash table，也叫哈希表），是根据关键码值（Key value）而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中-一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。 有一个公司，当有新的员工来报道时，要求将该员工的信息加入id，性别，年龄，名字，住址.），当输入该员工的id时，要求查找到该员工的所有信息 1）不使用数据库，速度越快越好=>哈希表（散列） 2）添加时，保证按照id从低到高插入[课后思考：如果id不是从低到高插入
哈希表+双向链表的组合使用
zhang0404的专栏
03-24 5838
工作五年，四年在一个老牌通信公司，做的核心网项目开发，整天关注的是call flow，所参与的项目基本和MM和Call Control相关， 大多重点在项目开发逻辑，以及信令的解析和分析上。 关于网络通信，进程间通信，以及多线程，享内存，进程管理，状态机，以及定时器，各种log机制基本使用公司成熟的方法接口。 对于其基本理论，大多使用时，并不仔细分析，仅仅是加以利用。 最近有了一些闲暇时间
LRU算法 C++实现（HashMap+双向链表）
weixin_45590210的博客
01-22 834
leetcode上测试代码的题目 LRU（最近最少使用算法），是缺页置换解决方法中的一种。时间复杂度优秀O（1），空间复杂度不算哈希表本身的消耗的话还会多出维护双向链表左右指针的2N大小的空间消耗。 具体实现方法就是在原有数据结构（一般是哈希表）的基础上套上一个双向链表。当操作（询问，修改，增加）某个链表中某个元素的时候把这个元素移动到链表头上。当缓存区满了的时候去掉链表尾上的那个元素即可。 代码实现（HashSet和双向链表都是自实现的）： class LRUCache { public: sta
数据结构-双向链表
04-14
若需要快速查找，可以结合哈希表等数据结构实现。 在`jwlist`这个上下文中，可能是指一个特定的双向链表实现库或框架，它可能提供了更高级的抽象和优化，比如线程安全、内存管理、迭代器支持等功能。 双向链表在很...
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 735
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
编译所有常用数据结构和算法的简单库，包括链表、哈希映射和数组列表等
最新发布
03-01
链表分为单向链表和双向链表，前者只能按一个方向遍历，后者则可以向前或向后遍历。链表的主要操作包括插入、删除和查找，其优点在于插入和删除操作通常比数组更快，因为只需改变几个指针即可，而不需要移动大量元素...
设计一个Cache系统 【双向链表+哈希表】
u010585135的专栏
03-21 746
转自：http://blog.csdn.net/yangcs2009/article/details/38351573 今天去面试，面试官让我设计一个cache系统，要求保证最近使用的数据不能被移除出cache,也就是每次添加一个cache项的时候，把最旧的cache项移除出去。     我只记得操作系统里貌似有个差不多的cache算法，记不起名字来，更别提数据结构了。一开始我执着
算法系列——实现LRU
BridgeGeorge
12-27 473
题目 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ；如果不存在，则向缓存中插入该组 key-value 。如果插入操作
实现一个简单的哈希表（数组 + 链表）
weixin_44501074的博客
11-22 2078
1、什么是哈希表 2、主要方法的逻辑和代码实现 1）put()方法 2）get()方法 3) remove()方法 1、哈希表 hash，哈希表这个词，以前接触过好多次了，对哈希表了解最多的就是，这玩意儿也是一种数据结构，而且哈希表查找、添加和删除元素都很快。 哈希表，跟链表一样，大都使用结点类型来存储值。哈希表的存储类型是种叫 键值对 <K, V> 的东西。 在本文中，我用的是一个数...
力扣146（双向链表加哈希表）
September_的博客
01-22 326
#include<bits/stdc++.h> using namespace std; typedef long long ll; class LRUCache { public: struct Node { public: int val,key; Node *next,*pre; Node(int a,...
大厂必备技能：数据结构之哈希表
zjjcchina的博客
08-07 218
前面我们讲了链表这种数据结构，相比于数组的好处是对元素在增删场景效率特别高，弥补了数组新增和删除效率极低的缺陷。同样链表也存在自己致命的缺陷，那就是查询和修改效率太低。其实数组和链表这两种数据结构刚好是互补的，只是前者的优点是后者的缺点，而后者的优点是前者的缺点。可以看出对这两种结构而言，并不是尽善尽美的，我们只能根据自己开发的场景选择其中最符合我们设计的数据结构。那么问题来了，有没有一种数据结构，能够充分利用这两者的优点，各取所长了。答案肯定是存在的，比如哈希表、树以及图等。今天咱们讲其中一种新的数据结构
LRU缓存——哈希表+双向链表
weixin_45594172的博客
10-06 1480
LRU缓存——哈希表+双向链表
linkedhashmap是双向链表
09-07
LinkedHashMap是一种哈希表和双向链表的结合。它继承自HashMap类，并且通过使用双向链表来维护元素的插入顺序。这使得LinkedHashMap在遍历时可以按照插入顺序或者访问顺序进行迭代。所以，LinkedHashMap既有哈希表的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值