算法之hashMap、LRU、bitMap、生产者消费者

最新推荐文章于 2023-09-18 16:14:20 发布
最新推荐文章于 2023-09-18 16:14:20 发布
阅读量526 收藏
点赞数
分类专栏： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014618114/article/details/107520363
版权

hashMap

//KVMap,首先，HashMap存储的是键值对，所以需要一个键值对类型。
//链表结构里数据的数据类型 键值对
type KV struct {
    Key string
    Value string
}

//LinkNode,键值对又是主要存储在链表里的，所以需要一个链表类。
//链表结构
type LinkNode struct {
    //节点数据
    Data KV
    //下一个节点
    NextNode *LinkNode
}

//创建只有头结点的链表
func CreateLink() *LinkNode {
   //头结点数据为空 是为了标识这个链表还没有存储键值对
    var linkNode = &LinkNode{KV{"",""}, nil}
    return linkNode
}

//当发生哈希碰撞时，键值对会存储在新建的链表节点上。这里需要一个添加节点的功能，我们这里采用尾插法添加节点。
//尾插法添加节点,返回链表总长度
func (link *LinkNode) AddNode(data KV) int {
    var count = 0
    //找到当前链表尾节点
    tail := link
    for {
        count += 1
        if tail.NextNode == nil {
            break
        }else {
            tail = tail.NextNode
        }
    }
    var newNode = &LinkNode{data, nil}
    tail.NextNode = newNode
    return count+1
}

//HashMap 接下来，就是猪脚HashMap登场了。
//HashMap木桶(数组)的个数
const BucketCount  = 16
type HashMap struct {
    //HashMap木桶
    Buckets [BucketCount]*LinkNode
}

//创建HashMap
func CreateHashMap() *HashMap {
    myMap := &HashMap{}
    //为每个元素添加一个链表对象
    for i := 0; i < BucketCount ; i++  {
        myMap.Buckets[i] = CreateLink()
    }

    return myMap
}

//我们需要一个哈希散列算法，将key转化为一个0-BucketCount的整数，作为存放它的数组的下标。这里这个散列算法，应尽可能随机地使新增的键值对均匀地分布在每个数组下。
//一般像go的map和Java的HashMap都会有一个复杂的散列算法来达到这个目的，我们这里只是为了讲HashMap原理，暂且就用一个简单的方法来求出下标。
//自定义一个简单的散列算法，它可以将不同长度的key散列成0-BucketCount的整数
func HashCode(key string) int {
    var sum = 0
    for i := 0; i < len(key); i++ {
        sum += int(key[i])
    }
    return (sum % BucketCount)
}

//往HashMap里添加键值对
//添加键值对
func (myMap *HashMap)AddKeyValue(key string, value string)  {

    //1.将key散列成0-BucketCount的整数作为Map的数组下标
    var mapIndex = HashCode(key)

    //2.获取对应数组头结点
    var link = myMap.Buckets[mapIndex]

    //3.在此链表添加结点
    if link.Data.Key == "" && link.NextNode == nil {
        //如果当前链表只有一个节点，说明之前未有值插入  修改第一个节点的值 即未发生哈希碰撞
        link.Data.Key = key
        link.Data.Value = value

        fmt.Printf("node key:%v add to buckets %d first node\n", key, mapIndex)
    }else {

        //发生哈希碰撞
        index := link.AddNode(KV{key, value})
        fmt.Printf("node key:%v add to buckets %d %dth node\n", key, mapIndex, index)
    }
}

//根据键从HashMap里取出对应的值,按键取值
func (myMap *HashMap)GetValueForKey(key string) string {
    //1.将key散列成0-BucketCount的整数作为Map的数组下标
    var mapIndex = HashCode(key)
    //2.获取对应数组头结点
    var link = myMap.Buckets[mapIndex]
    var value string
    //遍历找到key对应的节点
    head := link
    for {
        if head.Data.Key == key {
            value = head.Data.Value
            break
        }else  {
            head = head.NextNode
        }
    }
    return value
}

LRU算法

LRU是Least Recently Used的缩写，即最近最少使用，常用于页面置换算法，是为虚拟页式存储管理服务的。如果要自己实现一个LRU算法，可以用哈希表加双向链表实现：
在这里插入图片描述
设计思路是：使用哈希表存储 key，值为链表中的节点，节点中存储值，双向链表来记录节点的顺序，头部为最近访问节点。

LRU算法中有两种基本操作：

  1. get(key)：查询key对应的节点，如果key存在，将节点移动至链表头部。
  2. set(key, value)： 设置key对应的节点的值。如果key不存在，则新建节点，置于链表开头。如果链表长度超标，则将处于尾部的最后一个节点去掉。如果节点存在，更新节点的值，同时将节点置于链表头部。
    lru缓存**

设计LRU缓存结构，该结构在构造时确定大小，假设大小为K，并有如下两个功能

  • set(key, value)：将记录(key, value)插入该结构
  • get(key)：返回key对应的value值

[要求]

  1. set和get方法的时间复杂度为O(1)
  2. 某个key的set或get操作一旦发生，认为这个key的记录成了最常使用的。
  3. 当缓存的大小超过K时，移除最不经常使用的记录，即set或get最久远的。

若opt=1，接下来两个整数x, y，表示set(x, y)
若opt=2，接下来一个整数x，表示get(x)，若x未出现过或已被移除，则返回-1
对于每个操作2，输出一个答案

示例：输入：

[[1,1,1],[1,2,2],[1,3,2],[2,1],[1,4,4],[2,2]],3

返回值：

[1,-1]

说明：

第一次操作后：最常使用的记录为("1", 1)
第二次操作后：最常使用的记录为("2", 2)，("1", 1)变为最不常用的
第三次操作后：最常使用的记录为("3", 2)，("1", 1)还是最不常用的
第四次操作后：最常用的记录为("1", 1)，("2", 2)变为最不常用的
第五次操作后：大小超过了3，所以移除此时最不常使用的记录("2", 2)，加入记录("4", 4)，并且为最常使用的记录，然后("3", 2)变为最不常使用的记录

#include <unordered_map>
 
struct DListNode{
    int key, val;
    DListNode* pre;
    DListNode* next;
    DListNode(int k, int v): key(k), val(v), pre(nullptr), next(nullptr){};
};
 
 
class Solution {
private:
    int size = 0;
    DListNode* head;
    DListNode* tail;
    unordered_map<int, DListNode*> mp;
 
public:
    /**
     * lru design
     * @param operators int整型vector<vector<>> the ops
     * @param k int整型 the k
     * @return int整型vector
     */
    vector<int> LRU(vector<vector<int> >& operators, int k) {
        // write code here
        if(k < 1) return {};
        this->size = k;
        this->head = new DListNode(0,0);
        this->tail = new DListNode(0,0);
        this->head->next = this->tail;
        this->tail->pre = this->head;
 
        if(operators.size() == 0) return {};
 
        vector<int> res;
 
        for(vector<int> op : operators){
            if(op[0] == 1) {
                set(op[1], op[2]);
            }else if(op[0] == 2){
                int value = get(op[1]);
                res.push_back(value);
            }
        }
        return res;
    }
 
    void set(int key, int val){
        if(mp.find(key) == mp.end()){ // hashmap 中没找到
            DListNode* node = new DListNode(key, val);
            mp[key] = node;
            if(this->size <= 0){
                removeLast();
            }
            else{
                this->size--;
            }
            insertFirst(node);
        }
        else{  // hashmap 中已经有了，也就是链表里也已经有了
            mp[key]->val = val;
            moveToHead(mp[key]);
        }
    }
 
 
    int get(int key){
        int ret = -1;
        if(mp.find(key) != mp.end()){
            ret = mp[key]->val;
            moveToHead(mp[key]);
        }
        return ret;
    }
 
    void moveToHead(DListNode* node){
        if(node->pre == this->head) return;
        node->pre->next = node->next;
        node->next->pre = node->pre;
        insertFirst(node);
    }
 
 
    void removeLast(){
        mp.erase(this->tail->pre->key);
        this->tail->pre->pre->next = this->tail; // remove the last node in dlist
        this->tail->pre = this->tail->pre->pre;
    }
 
    void insertFirst(DListNode* node){
        node->pre = this->head;
        node->next = this->head->next;
        this->head->next->pre = node;
        this->head->next = node;
    }
 
};

生产者消费者

type Product struct {
    name  int
    value int
}

func producer(wg *sync.WaitGroup, products chan<- Product, name int, stop *bool) {
    for !*stop {
        product := Product{name: name, value: rand.Int()}
        products <- product
        fmt.Printf("producer %v produce a product: %#v\n", name, product)
        time.Sleep(time.Duration(200+rand.Intn(1000)) * time.Millisecond)
    }
    wg.Done()
}

func consumer(wg *sync.WaitGroup, products <-chan Product, name int) {
    for product := range products {
        fmt.Printf("consumer %v consume a product: %#v\n", name, product)
        time.Sleep(time.Duration(200+rand.Intn(1000)) * time.Millisecond)
    }
    wg.Done()
}
//主线程
var wgp sync.WaitGroup
var wgc sync.WaitGroup
stop := false
products := make(chan Product, 10)

// 创建 5 个生产者和 5 个消费者
for i := 0; i < 5; i++ {
    go producer(&wgp, products, i, &stop)
    go consumer(&wgc, products, i)
    wgp.Add(1)
    wgc.Add(1)
}

time.Sleep(time.Duration(1) * time.Second)
stop = true     // 设置生产者终止信号
wgp.Wait()      // 等待生产者退出
close(products) // 关闭通道
wgc.Wait()      // 等待消费者退出

bitMap的简单实现

对于任意一个数x，x / 32对应着它在vector的第几个位置，x % 32对应它的比特位。
下面给出C++代码的实现。

class BitMap
{
public:
    BitMap(size_t num)
    {
        _v.resize((num >> 5) + 1); // 相当于num/32 + 1
    }

    void Set(size_t num) //set 1
    {
        size_t index = num >> 5; // 相当于num/32
        size_t pos = num % 32;
        _v[index] |= (1 << pos);
    }

    void ReSet(size_t num) //set 0
    {
        size_t index = num >> 5; // 相当于num/32
        size_t pos = num % 32;
        _v[index] &= ~(1 << pos);
    }

    bool get(size_t num)//check whether it exists
    {
        size_t index = num >> 5;
        size_t pos = num % 32;
        bool flag = false;
        if (_v[index] & (1 << pos))
            flag = true;
        return flag;

    }

private:
    vector<size_t> _v;
};

进程交替打印

让两个线程互相唤醒对方来交替打印数字

#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <stdio.h>

int g_num = 1;
pthread_mutex_t mutex;
pthread_cond_t cond1,cond2;

void* thread1(void* arg)
{
	while(1)
	{
		pthread_mutex_lock(&mutex);
        //如果需要交替打印一定范围(例如1-10)内的数字，那么可以加上下面两行代码
        //if(g_num > 10)
           //exit(1);
        printf("Thread1: %d \n",g_num);
        g_num ++;
        pthread_cond_signal(&cond2);
        pthread_cond_wait(&cond1,&mutex);		
		pthread_mutex_unlock(&mutex);
		sleep(1);
	}
	return NULL;
}

void* thread2(void* arg)
{
	while(1)
	{
        //这个sleep(1)加在前面是因为开启线程时有可能是线程2先打印，
        //导致变成thread2输出奇数，threa1输出偶数。为了避免这种情况，可以在延迟下线程2的打印。
        sleep(1);
		pthread_mutex_lock(&mutex);
        printf("Thread2: %d \n",g_num);
		g_num++;
        pthread_cond_signal(&cond1);
        pthread_cond_wait(&cond2,&mutex);
		pthread_mutex_unlock(&mutex);
		
	}
	return NULL;
}
int main()
{
	pthread_t p1,p2;
	
	pthread_mutex_init(&mutex,NULL);
	pthread_cond_init(&cond1,NULL);
	pthread_cond_init(&cond2,NULL);	
	
	pthread_create(&p1,NULL,thread1,NULL);
	pthread_create(&p2,NULL,thread2,NULL);
    pthread_join(p1,NULL);
	pthread_join(p2,NULL);
	
	pthread_mutex_destroy(&mutex);
	pthread_cond_destroy(&cond1);
	pthread_cond_destroy(&cond2);

	return 0;
}
迪崽~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剖析LinkedHashMap 和 LRU实现的种种
黄老师的博客
01-31 424
文章目录1、LinkedHashMap数据结构2、LinkedHashMap知识要点2.1、LinkedHashMap构造方法的accessOrder参数2.2、LinkedHashMap在HashMap基础上额外维护一个双向链表2.3、put（key, value）新增数据时2.4、get（key）访问数据时3、实现一个LRU3.1、LinkedHashMap是天生的LRU3.2、线程安全的LRU3.3、可以设置过期时间的LRU3.4、Guava怎么做的 1、LinkedHashMap数据结构 一图便
数据结构零基础入门（初学者也能看懂）：bitmap
pwater的博客
12-19 507
bitmap hashmap 节省内存
基于 HashMap 和 双向链表实现 LRU 算法
RitaAndWakaka的博客
05-27 684
LRU原理 假设内存只能容纳3个页大小，按照 7 0 1 2 0 3 0 4 的次序访问页。假设内存按照栈的方式来描述访问时间，在上面的，是最近访问的，在下面的是，最远时间访问的，LRU就是这样工作的。 但是如果让我们自己设计一个基于 LRU 的缓存，这样设计可能问题很多，这段内存按照访问时间进行了排序，会有大量的内存拷贝操作，性能差。 那么如何设计一个LRU缓存，使得放入和移除都是 O(1) ？ 我们需要把访问次序维护起来，但是不能通过内存中的真实排序来反应，有一种方案就是使用双向链表。 基
基于源码搞懂LinkedHashMap并通过其实现LRU算法
打酱油的葫芦娃
05-07 3587
LinkedHashMap 是通过哈希表和双向链表来实现的，其基于双向链表来保证对哈希表迭代时的有序性。 LinkedHashMap 继承自 HashMap，从而可以直接复用 HashMap 对哈希表的操作逻辑，其只需要额外维护1套双向链表的操作逻辑即可。 public class LinkedHashMap<K,V> extends HashMap<K,V> implements Map<K,V> { ...... } 节点 LinkedHashMa
海量数据去重的Hash、bitmap、BloomFilter、分布式一致性hash
qq_29750559的博客
06-05 756
布隆过滤器是一种概率型数据结构，它的特点是高效地插入和查询，能确定某个字符串一定不存在或者可能存在；优缺点：布隆过滤器相⽐传统的查询结构（例如：hash，set，map等数据结构）更加⾼效，占⽤空间更⼩，但是确定是它返回的结果是概率性的，结果存在一定的误差，误差可控，同时不支持删除操作构成：位图（bit数组）+ n个hash函数。
LRU缓存HashMap+双向链表
01-11
LRU缓存HashMap+双向链表实现，java版本，导入即用
Java8 HashMap扩容算法实例解析
08-25
主要介绍了Java8 HashMap扩容算法实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
树tree、动态数组dyArray、hashMap、拼图算法.zip
11-09
树tree、动态数组dyArray、hashMap、拼图算法.zip
rust使用的自定义哈希算法（加上 hashmap/set 别名）：快速、确定性_rust_代码_下载
06-10
liballoc 中的 hashmap 默认使用 SipHash，它并没有我们想要的那么快。在编译器中，我们并不真正担心 DOS 尝试，因此我们使用快速非加密哈希。 这与 Firefox 使用的算法相同——它是一种不基于任何广为人知的算法的...
面试题之详解HashMap
12-21
本文着重介绍关于Hashmap的常见面试题，读者需对HashMap有基本的了解 文章目录1.HashMap长度为什么是2的幂次方2.HashMap多线程操作导致死循环问题3.HashMap的底层实现4.扩容机制 1.HashMap长度为什么是2的幂次方 ...
数据结构与算法之Hash&BitMap
qq_67801847的博客
09-18 123
比如假设我们有N{2，3，64}个数中最大的是MAX，那么我们只需要开int[MAX /32+1]个int数组就可以存储完这些数据，具体可以看以下结构： Int a : 0000 0000 0000 0000 0000 0000 0000 0000 这里是32个位置，我们可以利用每个位置的0或者1来表示该位置的数是否存在,这样我们就可以得到以下存储结构：具体我们可以画个图来展示。我们再来看data[2]的第二位是否是1，如果是1则列表中存在65，否则不存在。右移 >>:8 >> : 8 / 4 = 2。
设计哈希集合（HashSet）(HashMap,BitMap)
AjwlForever虞启贤的微博
03-13 686
705.设计哈希集合（HashSet） 不使用任何内建的哈希表库设计一个哈希集合（HashSet）。 实现 MyHashSet 类： void add(key) 向哈希集合中插入值 key 。 bool contains(key) 返回哈希集合中是否存在这个值 key 。 void remove(key) 将给定值 key 从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。 提示： 0 <= key <=KaTeX parse error: Expected 'EOF', got '&a
HashMap、lru、散列表
jx69693678nab的博客
01-01 158
HashMap HashMap的数据结构：HashMap实际上是一个数组和链表（“链表散列”）的数据结构。底层就是一个数组结构，数组中的每一项又是一个链表。 hashCode是一个对象的标识，Java中对象的hashCode是一个int类型值。通过hashCode来算出指定数组的索引可以快速定位到要找的对象在数组中的位置，之后再遍历链表找到对应值，理想情况下时间复杂度为O(1)，并且不同对象可...
HashMap+双向链表实现LRU缓存机制
行者无疆的博客
01-27 607
  学过操作系统的同学应该知道，LRU指的是最近最久未使用页面置换算法，即容量填满时将最近最久未使用的对象删除。在Java中有着LinkedHashMap类，底层就是用双向链表+HashMap实现的，今天就教大家如何手撕LRU缓存机制。 leetcode 146. LRU 缓存机制   运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。   实现 LRUCache 类：   LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
LinkedHashMap实现LRU
张井天的博客
05-12 2259
前言： LinkedHashMap是HashMap的子类,在原有HashMap数据结构的基础上,它还维护着一个双向链表链接所有entry,这个链表定义了迭代顺序，通常是数据插入的顺序。 上图我只画了链表，其实红黑树节点也是一样的，只是节点类型不一样而已 也就是说我们遍历LinkedHashMap的时候,是从head指针指向的节点开始遍历,一直到tail指向的节点。 源码 public class LinkedHashMap<K,V> extends HashMap<K,V> imp
HashMap实现LRU（最近最少使用）缓存更新算法
zhaohong_bo的专栏
05-30 3480
最近阿里巴巴电话面试被问到了如何使用固定容量的HashMap，实现LRU算法。当时一脸懵逼，平时用HashMap也就用来快速存取数据而已，容量都是不限的。 想了半天，想到对node节点进行扩展，加入引用计数，然后到达指定容量后，删除引用计数最少的。 面试官质疑这样效率太低了，能不能优化下。 想到删除时，需要遍历所有元素，代价为O(n)，太大了。想到可以用最小堆来进行筛选。被问到建堆的节点值是什么，...
使用LinkedHashMap实现LRU算法
张维鹏的博客
01-31 6765
LRU算法，最近最少使用原则，如果要实现该算法，可以借助LinkedHashMap数据结构，LinkedHashMap继承HashMap，底层使用哈希表和双向链表来保存所有元素，使用LinkedHashMap可以确保元素按照顺序进行存储。 默认情况下，LinkedHashMap是按照元素的添加顺序存储，也可以启用按照访问顺序存储，即最近读取的数据放在最前面，最早读取的数据放在最后面，然后它还有一个判断是否删除最老数据的方法，默认是返回false，即不删除数据。 下面就基于这两种存储方式，简单展示一下如何
基于 HashMap 和 双向链表实现 LRU
ikun的博仔的博客
06-26 879
基于HashMap和双向链表实现LRU
索引3：Hash索引与BitMap索引
qq_41627514的博客
02-11 2644
Hash索引原理： hash索引是将索引键通过hash运算后，将运算结果的hash值和对应的行指针信息存储Bucket。 引用：‘’哈希索引（hash index）基于哈希表实现，只有精确匹配索引所有列的查询才有效。对于每一行数据，存储引擎都会对所有的索引列计算一个哈希码（hash code），哈希码是一个较小的值，并且不同键值的行计算出来的哈希码也不一样。哈希索引将所有的哈希码存储在索引中，同时...
hashmap寻址算法
最新发布
03-27
在HashMap中，寻址算法是用来确定键值对应的存储桶位置的方法。 HashMap的寻址算法主要包括以下几个步骤： 1. 哈希函数计算：当插入或查找一个键时，首先会使用哈希函数对键进行计算，得到一个哈希值。 2. 哈希值...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值