【数据结构】图算法和LRUCache

最新推荐文章于 2025-05-04 10:59:29 发布
最新推荐文章于 2025-05-04 10:59:29 发布
阅读量595 收藏
点赞数
分类专栏： 数据结构笔记 文章标签： 算法 数据结构 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_53893431/article/details/128226983
版权

文章目录

最小生成树

1.最小生成树概念

连通图中的每一棵生成树，都是原图的一个极大无环子图，即：从其中删去任何一条边，生成树就不在连通；反之，在其中引入任何一条新边，都会形成一条回路。

若连通图由n个顶点组成，则其生成树必含n个顶点和n-1条边。因此构造最小生成树的准则有三条：

  1. 只能使用图中的边来构造最小生成树
  2. 只能使用恰好n-1条边来连接图中的n个顶点
  3. 选用的n-1条边不能构成回路

最小生成树，也就是图的生成树中权值最小的树。最小生成树的常用算法有Kruskal算法 和**Prim算法。**算法的思想都是贪心策略。

2.Kruskal算法

核心：贪心思想。

逐步选择当前图中的最小边，选择边构成生成树。要注意选择的边不能构成环。

image-20221207195837894

如何判断是否有环？ 并查集

被选择的边的点合并到一共集合中。如果被选中的边两端的点已经在一共集合中，说明构成了环。

下面用图的邻接矩阵实现克鲁斯卡尔算法。

 //克鲁斯卡尔算法
W Kruskal(self &minTree)
{
    //构建一共只有点，没有边的图。后续最小生成树的边往图里面添加
    size_t n = _vertexs.size();
    minTree._vertexs = _vertexs;
    minTree._indexmap = _indexmap; 
    minTree._matrix.resize(n);
    for (int i = 0; i < n; i++)
    {
        minTree._matrix[i].resize(n, MAX_W);
    }
    //将所有的边，放入到一个优先级队列中
    priority_queue<edge, vector<edge>, greater<edge>> minque;
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = 0; j < n; j++)
        {
            //无向的，保证不重复的选择边
            if (i < j && _matrix[i][j] != MAX_W)
            {
                //将边插入到优先级队列中
                minque.push(edge(i, j, _matrix[i][j]));
            }
        }
    }
    //依次选边
    W ret = W();      //总的权值
    int edge_num = 0; //一共要选择n-1条边
    //并查集判断是否有环
    UnionFindSet<V> points;
    //将图的点依次插入到并查集中
    for (int i = 0; i < _vertexs.size(); i++)
    {
        points.insert(_vertexs[i]);
    }
    while (!minque.empty())
    {
        edge min = minque.top();
        minque.pop();
        //判断是否成环
        if (!points.InSet_index(min._srci, min._dsti))
        {
            //添加边
            minTree._addedge(min._srci, min._dsti, min._w);
            points.Union(min._srci, min._dsti);
            edge_num++;
            ret += min._w;
        }
    }
    //判断边是否选完
    if (edge_num != n - 1)
    {
        return W();
    }

    return ret;
}

测试克鲁斯卡尔算法

void leaset_tree()
{
    const char* str = "abcdefghi";
    matrix::Graph<char, int> g(str, strlen(str));
    g.addedge('a', 'b', 4);
    g.addedge('a', 'h', 8);
    // g.AddEdge('a', 'h', 9);
    g.addedge('b', 'c', 8);
    g.addedge('b', 'h', 11);
    g.addedge('c', 'i', 2);
    g.addedge('c', 'f', 4);
    g.addedge('c', 'd', 7);
    g.addedge('d', 'f', 14);
    g.addedge('d', 'e', 9);
    g.addedge('e', 'f', 10);
    g.addedge('f', 'g', 2);
    g.addedge('g', 'h', 1);
    g.addedge('g', 'i', 6);
    g.addedge('h', 'i', 7);
    //构建一颗最小生成树
    matrix::Graph<char, int> mintree;
    g.Kruskal(mintree);
    mintree.Print();
}

image-20221207200729581

3.Prim算法

Prim算法是从给定的结点出发，依次从被选择集合出发的点选择最小的边，被选中边的点加入到被选择集合中。

image-20221207200921392

下面用图的邻接矩阵实现克鲁斯卡尔算法。

W Prim(self &minTree, const V &src)
{

    size_t n = _vertexs.size();
    int srci = GetVertexIndex(src);
    minTree._vertexs = _vertexs;
    minTree._indexmap = _indexmap;
    minTree._matrix.resize(n);
    for (size_t i = 0; i < n; ++i)
    {
        minTree._matrix[i].resize(n, MAX_W);
    }
    vector<bool> choice(n, false);
    vector<bool> nochoice(n, true);
    priority_queue<edge, vector<edge>, greater<edge>> minque;
    choice[srci] = true;
    nochoice[srci] = false;
    for (size_t i = 0; i < n; i++)
    {
        if (_matrix[srci][i] != MAX_W)
        {
            minque.push(edge(srci, i, _matrix[srci][i]));
        }
    }
    size_t edge_num = 0;
    W total = W(); //返回值
    while (!minque.empty())
    {
        edge min = minque.top();
        minque.pop();
        //判断当前的边是否合法
        if (choice[min._dsti])
        {
            // do nothing
        }
        else
        {
            //将当前边添加到图中
            minTree._addedge(min._srci, min._dsti, min._w);
            choice[min._dsti] = true;
            nochoice[min._dsti] = false;
            edge_num++;
            total += min._w;
            if (edge_num == n - 1)
            {
                break;
            }
            for (size_t i = 0; i < n; i++)
            {
                if (nochoice[i] && _matrix[min._dsti][i] != MAX_W)
                {
                    minque.push(edge(min._dsti, i, _matrix[min._dsti][i]));
                }
            }
        }
    }
    if (edge_num != n - 1)
    {
        return W();
    }
    return total;
}

测试Prim算法

void leaset_tree()
{
    const char* str = "abcdefghi";
    matrix::Graph<char, int> g(str, strlen(str));
    g.addedge('a', 'b', 4);
    g.addedge('a', 'h', 8);
    // g.AddEdge('a', 'h', 9);
    g.addedge('b', 'c', 8);
    g.addedge('b', 'h', 11);
    g.addedge('c', 'i', 2);
    g.addedge('c', 'f', 4);
    g.addedge('c', 'd', 7);
    g.addedge('d', 'f', 14);
    g.addedge('d', 'e', 9);
    g.addedge('e', 'f', 10);
    g.addedge('f', 'g', 2);
    g.addedge('g', 'h', 1);
    g.addedge('g', 'i', 6);
    g.addedge('h', 'i', 7);
    //构建一颗最小生成树
    matrix::Graph<char, int> mintree;
    g.Prim(mintree,'a');
    mintree.Print();
}

image-20221207203535048

最短路径算法

单源最短路径–Dijkstra算法

也叫做单源最短路径算法，解决一个点到其余个点顶点的最短路径

image-20220619003829502

首先需要写出邻接矩阵

image-20220619003901576

使用dis数组存储源顶点(1号顶点)到其余个顶点的距离

image-20220619003958233

具体思路

  • 从初始的dis数组中找到最小值为2，那么1->2顶点的最短路径就成为了确定值，值为1。

  • 从顶点2开始出发，可以到达的顶点为2->3,2->4;其中如果中顶点2进行"中转",那么1->2->3的路径为1(1->2的最短路径)+9(2->3的路径)为10，小于1->3的距离12，所以将dis数组中1->3的值变为10；对2->4进行同样的处理1->4的最短路径更新为4。

image-20220619005019121

在现在的dis数组中，确定的顶点有2；而第一次松弛后除去到顶点2的最短路径为1->4(路径长度为4)，顶点4为确定值。从4开始出发

  • 可以到达的顶点有3，5，6；将顶点4作为"中转"进行第二轮的松弛

image-20220619005311208

现在的确定的顶点为2，4；剩下顶点的最短路径为1->3,顶点3为最短路径，变为确定值；

进行下一轮的松弛

image-20220619005419967

最终的松弛结果为：

image-20220619005447294

dis数组中存放了到各顶点的最短路径

// Dijkstra是单源最短路算法，可以计算给定点到其他点的最短路
void Dijkstra(const V &src, vector<W> &dist, vector<int> &parentindex)
{
    // dist，记录到i点的当前最短路是多少
    int srci = GetVertexIndex(src);
    size_t n = _vertexs.size();
    dist.resize(n, MAX_W);
    parentindex.resize(n, -1);
    parentindex[srci] = srci;
    vector<bool> visited(n, false);
    //先对dist数组进行初始化
    /*
    for(size_t i=0;i<n;i++){
        if(_matrix[srci][i]!=MAX_W){
            dist[i]=_matrix[srci][i];
        }
    }
    visited[srci]=true;
    */
    dist[srci] = 0;
    //寻找最短的路径,每一轮对其中一个点进行松弛处理,一共要进行n轮
    for (size_t i = 0; i < n; i++)
    {

        //记录这一轮的最小路径和最小节点
        int min_index = 0;
        W min_num = MAX_W;
        //先找到当前一轮的最小值和最小节点
        for (size_t j = 0; j < n; j++)
        {
            if (!visited[j] && dist[j] < min_num)
            {
                min_num = dist[j];
                min_index = j;
            }
        }
        //当前的点为确定点
        visited[min_index] = true;
        //松弛处理
        for (size_t j = 0; j < n; j++)
        {
            if (!visited[j] && dist[min_index] + _matrix[min_index][j] < dist[j] && _matrix[min_index][j] != MAX_W)
            {
                dist[j] = dist[min_index] + _matrix[min_index][j];
                parentindex[j] = min_index;
            }
        }
    }
}

image-20221207204012948

测试接口

void TestGraphDijkstra()
{
    const char* str = "syztx";
    matrix::Graph<char, int,MAX, true> g(str, strlen(str));
    g.addedge('s', 't', 10);
    g.addedge('s', 'y', 5);
    g.addedge('y', 't', 3);
    g.addedge('y', 'x', 9);
    g.addedge('y', 'z', 2);
    g.addedge('z', 's', 7);
    g.addedge('z', 'x', 6);
    g.addedge('t', 'y', 2);
    g.addedge('t', 'x', 1);
    g.addedge('x', 'z', 4);
    vector<int> dist;
    vector<int> parentPath;
    g.Dijkstra('s', dist, parentPath);
    g.PrintShortPath('s', dist, parentPath);
    for (auto& d : dist) {
        cout << d << " ";
    }
    cout << endl;
}

image-20221207204057262

Dijkstra算法存在的问题是不支持图中带负权路径，如果带有负权路径，则可能会找不到一些路
径的最短路径。

单源最短路径–Bellman-Ford算法

bellman—ford算法可以解决负权图的单源最短路径问题。它的优点是可以解决有负权边的单源最短路径问题，而且可以用来判断是否有负权回路。它也有明显的缺点，它的时间复杂度 O(N*E) (N是点数，E是边数)普遍是要高于Dijkstra算法O(N²)的。像这里如果我们使用邻接矩阵实现，那么遍历所有边的数量的时间复杂度就是O(N^3)，这里也可以看出来Bellman-Ford就是一种暴力求解更新 。

image-20221207204454551

void Bellman_Ford(const V &src, vector<W> &dist, vector<int> &pPath)
{
    size_t n = dist.size();
    size_t srci = GetVertexIndex(src);
    dist.resize(n, MAX_W);
    pPath.resize(n, -1);
    dist[srci] = W();
    for (size_t k = 0; k < n - 1; ++k)
    {
        bool exchange = false;
        for (size_t i = 0; i < n; ++i)
        {
            for (size_t j = 0; j < n; ++j)
            {
                // srci->i + i->j < srci->j 则更新路径及权值
                if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
                {
                    dist[j] = dist[i] + _matrix[i][j];
                    pPath[j] = i;
                    exchange = true;
                }
            }
        }
        if (exchange = false)
        {
            break;
        }
    }
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            // 检查有没有负权回路
            if (_matrix[i][j] != MAX_W && dist[i] + _matrix[i][j] < dist[j])
            {
                return false;
            }
        }
    }
}

多源最短路径–Floyd-Warshall算法

弗洛伊德算法是一种纯暴力算法，每次以K为中转转，更新结点i到结点j的最大路径。

image-20221207204731818

//弗洛伊德算法是一种纯暴力算法
void FloydWarshall(vector<vector<W>> &vvDist, vector<vector<int>> &vvpPath)
{
    size_t n = _vertexs.size();
    vvDist.resize(n);
    vvpPath.resize(n);
    for (size_t i = 0; i < n; ++i)
    {
        vvDist[i].resize(n, MAX_W);
        vvpPath[i].resize(n, -1);
    }

    //初始化
    for (size_t i = 0; i < n; i++)
    {
        for (size_t j = 0; j < n; j++)
        {
            if (_matrix[i][j] != MAX_W)
            {
                vvDist[i][j] = _matrix[i][j];
                vvpPath[i][j] = i;
            }
            if (i == j)
            {
                vvDist[i][j] = W();
            }
        }
    }

    //弗洛伊德算法
    //依次以K结点为中转站更新最短路径
    for (size_t k = 0; k < n; k++)
    {
        for (size_t i = 0; i < n; i++)
        {
            for (size_t j = 0; j < n; j++)
            {
                if (vvDist[i][k] != MAX_W && vvDist[k][j] != MAX_W && vvDist[i][k] + vvDist[k][j] < vvDist[i][j])
                {
                    vvDist[i][j] = vvDist[i][k] + vvDist[k][j];
                    vvpPath[i][j] = vvpPath[k][j];
                }
            }
        }
    }

    //打印节点
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            if (vvDist[i][j] == MAX_W)
            {
                // cout << "*" << " ";
                printf("%3c", '*');
            }
            else
            {
                // cout << vvDist[i][j] << " ";
                printf("%3d", vvDist[i][j]);
            }
        }
        cout << endl;
    }
    cout << endl;
    for (size_t i = 0; i < n; ++i)
    {
        for (size_t j = 0; j < n; ++j)
        {
            // cout << vvParentPath[i][j] << " ";
            printf("%3d", vvpPath[i][j]);
        }
        cout << endl;
    }
    cout << "=================================" << endl;
}

以下面的图进行测试

image-20221207204906198

void TestFloydWarShall()
{
    const char *str = "12345";
    matrix::Graph<char, int,MAX,true> g(str, strlen(str));
    g.addedge('1', '2', 3);
    g.addedge('1', '3', 8);
    g.addedge('1', '5', -4);
    g.addedge('2', '4', 1);
    g.addedge('2', '5', 7);
    g.addedge('3', '2', 4);
    g.addedge('4', '1', 2);
    g.addedge('4', '3', -5);
    g.addedge('5', '4', 6);
    vector<vector<int>> vvDist;
    vector<vector<int>> vvParentPath;
    g.FloydWarshall(vvDist, vvParentPath);
    // 打印任意两点之间的最短路径
    for (size_t i = 0; i < strlen(str); ++i)
    {
        g.PrintShortPath(str[i], vvDist[i], vvParentPath[i]);
        cout << endl;
    }
}

image-20221207205356042

LRUCache

LRU是Least Recently Used的缩写，意思是最近最少使用，它是一种Cache替换算法。

什么是Cache(缓存)？

狭义的Cache指的是位于CPU和主存间的快速RAM， 通常它不像系统主存那样使用DRAM技术，而使用昂贵但较快速的SRAM技术。 广义上的Cache指的是位于速度相差较大的两种硬件之间， 用于协调两者数据传输速度差异的结构。除了CPU与主存之间有Cache， 内存与硬盘之间也有Cache，乃至在硬盘与网络之间也有某种意义上的Cache── 称为Internet临时文件夹或
网络内容缓存等。
Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。

CPU三级缓存机制

image-20221207205745214

LRUCache实现

LRU Cache要保证获取和置换都是O(1)操作。常用方法是使用双向链表和哈希表的搭配 。双向链表存储Key-value键值对。Hash表中存放Key和链表结点的映射关系。

image-20221207205821680

class LRUCache{
public:
    LRUCache(int capacity)
        :capacity_(capacity)
    {}

    int get(int key){
        auto it=mp.find(key);
        //如果有该数据，就加入到头位置
        if(it!=mp.end()){
            //得到链表的迭代器
            auto list_iter=it->second;
            pair<int,int> listvalue=*list_iter;
            data.erase(list_iter);
            data.push_front(listvalue);
            mp[key]=data.begin();
            return listvalue.second;
        }
        //如果没有数据,返回-1
        else{
            return -1;
        }
    }


    void set(int key,int value){
        auto it=mp.find(key);
        if(it!=mp.end()){
            //如果已经有了key,更新数据,然后将其放在最前面
            auto list_iter=it->second;
            pair<int,int> list_value=*list_iter;
            list_value.second=value;
            data.erase(list_iter);
            data.push_front(list_value);    
            //更新Hash表
            mp[key]=data.begin();
        }
        //如果没有key,就需要判断容量
        //如果当前数量超过容量，就删除最后一个，负责之间在头添加即可
        else{
            if(data.size()>=capacity_){
               auto list_back=data.back();
               mp.erase(list_back.first);
               data.pop_back();
            }
            //向头部添加make_pair(key,value);
            data.push_front(make_pair(key,value));
            mp[key]=data.begin();
        }
    }
    //插入
private:
    unordered_map<int,list<pair<int,int>>::iterator> mp;
    //List存放一共K-Value类型的数据
    list<pair<int,int>> data;
    size_t capacity_;
};

146. LRU 缓存 - 力扣（LeetCode）

源码地址

Graph和LRUCache · 影中人/test - 码云 - 开源中国 (gitee.com)

LRU缓存（LRUCache）
爱写bug的王六六
02-27 5543
146. LRU 缓存 题目描述： 请你设计并实现一个满足 LRU (最近最少使用) 缓存 约束的数据结构。 实现 LRUCache 类： LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存（cache） int get(int key)如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字 key 已经存在，则变更其数据值 value ； 如果不存在，则向缓存
【软件测试】面试题之数据结构与算法篇
weixin_46453070的博客
01-08 1311
数组更适合于索引访问密集型的场景，其中插入和删除操作相对较少。链表则适用于元素经常变化的场景，尤其是在列表的头部或中间插入和删除操作频繁发生的情况。在选择使用数组还是链表时，需要根据应用的需求和上述特点来决定。栈提供了快速的插入和删除操作，适合需要后进先出顺序的场景。队列提供了有序的插入和删除操作，适合需要先进先出顺序的场景。在选择栈还是队列时，关键是考虑数据的访问顺序和处理方式。哈希表通过将键映射到数组的索引上，提供了快速的数据访问速度。
LRUCache
Java Programming
08-10 137
package com.alibaba.dubbo.common.utils;   import java.util.LinkedHashMap; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock;   public class LRUCache&lt;K, ...
最小生成树
snowfoootball的博客
04-18 879
在一个连通无向图中，选出若干条边连接所有顶点，且边权和最小且不能有环，这形成的子图叫做最小生成树。生成树：包含图中所有点的树（无环、连通）最小生成树：在所有生成树中，边权和最小的那一个。
Lrucache
手指乐
12-29 580
Lrucacha，主要是get和set方法，存储的结构采用了LinkedHashMap，这种map内部实现了lru算法（Least Recently Used 近期最少使用算法）。 [java] view plaincopyprint? this.map = new LinkedHashMap(0, 0.75f, true);   最后一个参数
LeetCode LRUCache与数据结构&算法实践
资源摘要信息:"LeetCode LRU Cache 数据结构和算法代码库" 描述中提到的LeetCode是一个在线编程实践平台，它提供了一个广泛的题目库供程序员练习编程技能，特别是数据结构和算法的能力。这个特定的代码库关注于实现...
15.4Python数据结构与算法：实现LRUCache缓存类
欧阳桫的技术博客
10-16 550
@概述 LRUCache原理是将最近最少访问的（Least Recent Use）键值移出缓存，从而维护缓存容量在指定范围内 通过collections.OrderedDict数据结构，可以字典键值的形式存储缓存数据 通过不断将最新插入的键值移动到有序字典末尾，并将头部的数据清除的方式，我们可以动态维护缓存容量在指定的范围内，达到LRUCache算法的目的 @工具实现 # 引入有序字典 from collections import OrderedDict # 定义LRUCache类 class LR
数据结构与算法：数据结构设计相关题
2402_89326161的博客
02-03 1880
数据结构设计相关题
数据结构与算法的实用数据结构
最新发布
数据结构与算法学习宝典
05-04 420
聚焦工程实践中高频使用的核心数据结构，建立算法复杂度与硬件特性之间的映射模型，提供面向不同应用场景的数据结构选型决策框架。从线性结构到非线性结构，从基础实现到高级变种，结合内存布局分析和缓存命中率优化策略，构建完整的数据结构知识体系。fill:#333;color:#333;color:#333;fill:none;数据结构线性结构非线性结构数组链表树图动态数组双向链表二叉树堆。
Android基础-LruCache原理解析
weixin_30800807的博客
08-15 340
一、Android中的缓存策略 一般来说，缓存策略主要包含缓存的添加、获取和删除这三类操作。如何添加和获取缓存这个比较好理解，那么为什么还要删除缓存呢？这是因为不管是内存缓存还是硬盘缓存，它们的缓存大小都是有限的。当缓存满了之后，再想其添加缓存，这个时候就需要删除一些旧的缓存并添加新的缓存。 因此LRU(Least Recently Used)缓存算法便应运而生，LRU是最近最少使用...
LruCache
weixin_40290793的博客
12-12 5536
LruCache基础知识 1、LruCache是计算机科学经常使用的一种近期最少使用算法 2、LruCache内部采用的是LinkedHashMap 3、LruCache的出现时为了取代SoftReference Android 3.0之前做图片缓存主要用的就是SoftReference，3.0以后虚拟机更倾向于用SoftReference来索引对象，所以LruCache的出现就是为了
Android 关于使用LruCache缓存你想缓存的数据
飞翔的熊blabla
07-23 612
今天我们来一起学习一下缓存技术，相信大家做开发的时候都知道请求网络数据的重要，但是有一些只用请求一次就过时性的消息比如某些新闻信息，如果我们每次进入新闻界面就从新从网络上获取势必会给用户带来不好的体验，所以我们需要缓存技术来帮我们解决这一问题。 1,LruCache介绍 核心的类是LruCache (此类在android-support-v4的包中提供) 。这个类非常适合用来缓存图片，它的主要
LRuCache
车晋强的专栏
05-01 182
LruCache底层使用LinkedHashMap，因为LruCache中Lru算法的实现就是通过LinkedHashMap来实现的。LinkedHashMap继承于HashMap，它使用了一个双向链表来存储Map中的Entry顺序关系，这种顺序有两种，一种是LRU顺序，一种是插入顺序，这可以由其构造函数public LinkedHashMap(int initialCapacity,float ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

影中人lx

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值