【数据结构】LRUCache和跳表{简单讲解+模拟实现}

文章目录

  • LRUCache
  • SkipList

LRUCache

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。

Cache的容量有限，因此当Cache的容量用完后，而又有新的内容需要添加进来时， 就需要挑选并舍弃原有的部分内容，从而腾出空间来放新内容。LRU Cache 的替换原则就是将最近最少使用的内容替换掉。其实，LRU译成最久未使用会更形象， 因为该算法每次替换掉的就是一段时间内最久没有使用过的内容。
在这里插入图片描述

list::splice

void splice (iterator position, list& x);
void splice (const_iterator position, list& x);
void splice (const_iterator position, list&& x);

void splice (iterator position, list& x, iterator i);
void splice (const_iterator position, list& x, const_iterator i);
void splice (const_iterator position, list&& x, const_iterator i);

void splice (iterator position, list& x, iterator first, iterator last);
void splice (const_iterator position, list& x, const_iterator first, const_iterator last);
void splice (const_iterator position, list&& x, const_iterator first, const_iterator last);

在C++的std::list容器中，splice函数用于将一个列表（list）中的元素移动到另一个列表的指定位置，而不复制它们。这是通过调整内部指针（或节点链接）来实现的，因此是一个高效的操作。以下是您提到的三个splice函数重载的简要说明：

  1. void splice (iterator position, list& x);

    此函数将整个列表x中的所有元素移动到当前列表的position位置。移动后，列表x将变为空，而当前列表将在position处包含原列表x的所有元素。如果position是当前列表的end()迭代器，则x的元素将被添加到当前列表的末尾。

  2. void splice (iterator position, list& x, iterator i);

    此函数将单个元素从列表x移动到当前列表的position位置。元素是由迭代器i指定的，它必须指向列表x中的一个有效元素。移动后，迭代器i将不再指向列表x中的任何元素（因为它现在属于当前列表）。

  3. void splice (iterator position, list& x, iterator first, iterator last);

    此函数将列表x中由迭代器范围[first, last)指定的元素移动到当前列表的position位置。这个范围包括first指向的元素，但不包括last指向的元素。移动后，这个范围内的元素将不再属于列表x，而是成为当前列表的一部分。如果first和last相等，则不移动任何元素。

需要注意的是，在所有这些情况下，splice操作都不会复制元素，而是通过重新链接节点来移动它们。因此，这是一个常数时间操作（O(1)），尽管遍历列表以找到迭代器所指向的元素可能需要线性时间（O(n)），但这与splice函数本身的效率无关。此外，splice函数要求所有涉及的迭代器都是有效的，并且属于指定的列表（在调用splice之前）。

146. LRU 缓存 - 力扣（LeetCode）

/**
 * Your LRUCache object will be instantiated and called as such: // 实例化和调用
 * LRUCache* obj = new LRUCache(capacity);
 * int param_1 = obj->get(key);
 * obj->put(key,value);
 */
class LRUCache {
    typedef list<pair<int, int>>::iterator ListIt;
    int _capacity;
    unordered_map<int, ListIt> _hashmap;
    list<pair<int, int>> _LRUlist;

public:
    LRUCache(int capacity) : _capacity(capacity) {}

    int get(int key) {
        auto it = _hashmap.find(key);
        if (it != _hashmap.end()) {
            // 将该关键字移动到LRU队列头
            ListIt listit = it->second;
            _LRUlist.splice(_LRUlist.begin(), _LRUlist, listit);
            return listit->second;
        } else
            return -1;
    }

    void put(int key, int value) {
        auto it = _hashmap.find(key);
        if (it == _hashmap.end()) {
            // 判满，如果满了逐出最久未使用的关键字
            if (_hashmap.size() == _capacity) {
                pair<int, int> back = _LRUlist.back();
                _hashmap.erase(back.first);
                _LRUlist.pop_back();
            }
            // 将关键字插入到LRU队列头
            _LRUlist.push_front(make_pair(key, value));
            _hashmap.insert(make_pair(key, _LRUlist.begin()));

        } else {
            // 找到了更新其value值，并将该关键字移动到LRU队列头
            ListIt listit = it->second;
            listit->second = value;
            _LRUlist.splice(_LRUlist.begin(), _LRUlist, listit);
        }
    }
};

SkipList

Redis的内部数据结构——skiplist；skiplist，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一个有序的链表，查找数据的时间复杂度是O(N)。

skiplist本质上也是一种查找结构，用于解决算法中的查找问题（Searching），即根据给定的key，快速查到它所在的位置（或者对应的value）。

一般查找问题的解法分为两个大类：一个是基于各种平衡树，一个是基于哈希表。但skiplist却比较特殊，它没法归属到这两大类里面。

William Pugh开始的优化思路：

  • 假如我们每相邻两个节点升高一层，增加一个指针，让指针指向下下个节点，如下图b所示。这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半。由于新增加的指针，我们不再需要与链表中每个节点逐个进行比较了，需要比较的节点数大概只有原来的一半。

  • 以此类推，我们可以在第二层新产生的链表上，继续为每相邻的两个节点升高一层，增加一个指针，从而产生第三层链表。如下图c，这样搜索效率就进一步提高了。

  • skiplist正是受这种多层链表的想法的启发而设计出来的。实际上，按照上面生成链表的方式，上面每一层链表的节点个数，是下面一层的节点个数的一半，这样查找过程就非常类似二分查找，使得查找的时间复杂度可以降低到O(log n)。

  • 但是这个结构在插入删除数据的时候有很大的问题，插入或者删除一个节点之后，就会打乱上下相邻两层链表上节点个数严格的2:1的对应关系。如果要维持这种对应关系，就必须把新插入的节点后面的所有节点（也包括新插入的节点）重新进行调整，这会让时间复杂度重新蜕化成O(n)。

在这里插入图片描述

插入与删除的处理

  • skiplist的设计为了避免这种问题，做了一个大胆的处理，不再严格要求对应比例关系，而是插入一个节点的时候随机出一个层数。这样每次插入和删除都不需要考虑其他节点的层数，这样就好处理多了。在这里插入图片描述

设计跳表：1206. 设计跳表 - 力扣（LeetCode）

struct SkiplistNode
{
    int _val;
    vector<SkiplistNode *> _nextArr;

    SkiplistNode(int val, int level)
        : _val(val), _nextArr(level, nullptr)
    {
    }
};

class Skiplist
{
    typedef SkiplistNode Node;

private:
    Node *_head;
    size_t _maxLevel = 32;
    double _p = 0.25;

public:
    Skiplist()
    {
        srand(time(0));

        // 头节点，层数是1
        _head = new Node(-1, 1);
    }

    bool search(int target)
    {
        Node *cur = _head;
        int level = _head->_nextArr.size() - 1;
        while (level >= 0)
        {
            // 目标值比下一个节点值要大，向右走
            // 下一个节点是空(尾)，目标值比下一个节点值要小，向下走
            if (cur->_nextArr[level] && cur->_nextArr[level]->_val < target)
            {
                // 向右走
                cur = cur->_nextArr[level];
            }
            else if (cur->_nextArr[level] == nullptr || cur->_nextArr[level]->_val > target)
            {
                // 向下走
                --level;
            }
            else
            {
                return true;
            }
        }

        return false;
    }

    vector<Node *> FindPrevNode(int num)
    {
        Node *cur = _head;
        int level = _head->_nextArr.size() - 1;

        // 插入位置每一层前一个节点指针
        vector<Node *> prevV(level + 1, _head);

        while (level >= 0)
        {
            // 目标值比下一个节点值要大，向右走
            // 下一个节点是空(尾)，目标值比下一个节点值要小，向下走
            if (cur->_nextArr[level] && cur->_nextArr[level]->_val < num)
            {
                // 向右走
                cur = cur->_nextArr[level];
            }
            else if (cur->_nextArr[level] == nullptr || cur->_nextArr[level]->_val >= num)
            {
                // 更新level层前一个
                prevV[level] = cur;

                // 向下走
                --level;
            }
        }

        return prevV;
    }

    void add(int num)
    {
        vector<Node *> prevArr = FindPrevNode(num);

        int n = RandomLevel();
        Node *newnode = new Node(num, n);

        // 如果n超过当前最大的层数，那就升高一下_head的层数
        if (n > _head->_nextArr.size())
        {
            _head->_nextArr.resize(n, nullptr);
            prevArr.resize(n, _head);
        }

        // 链接前后节点
        for (size_t i = 0; i < n; ++i)
        {
            newnode->_nextArr[i] = prevArr[i]->_nextArr[i];
            prevArr[i]->_nextArr[i] = newnode;
        }
    }

    bool erase(int num)
    {
        vector<Node *> prevV = FindPrevNode(num);

        // 第一层下一个不是val，val不在表中
        if (prevV[0]->_nextArr[0] == nullptr || prevV[0]->_nextArr[0]->_val != num)
        {
            return false;
        }
        else
        {
            Node *del = prevV[0]->_nextArr[0];
            // del节点每一层的前后指针链接起来
            for (size_t i = 0; i < del->_nextArr.size(); i++)
            {
                prevV[i]->_nextArr[i] = del->_nextArr[i];
            }
            delete del;

            // 如果删除最高层节点，把头节点的层数也降一下
            int i = _head->_nextArr.size() - 1;
            while (i >= 0)
            {
                if (_head->_nextArr[i] == nullptr)
                    --i;
                else
                    break;
            }
            _head->_nextArr.resize(i + 1);

            return true;
        }
    }

    int RandomLevel()
    {
        size_t level = 1;
        // rand() ->[0, RAND_MAX]之间
        while (rand() <= RAND_MAX * _p && level < _maxLevel)
        {
            ++level;
        }

        return level;
    }
    int RandomLevel2()
    {
        // 静态随机数生成器 只会在第一次调用该函数时被初始化
        // 生成器的种子是当前时间自纪元(1970年1月1日)以来的纳秒数
        static std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
        // 静态均匀分布对象 用于生成 [0.0, 1.0) 范围内的双精度浮点数
        static std::uniform_real_distribution<double> distribution(0.0, 1.0);

        size_t level = 1;
        while (distribution(generator) <= _p && level < _maxLevel)
        {
            ++level;
        }

        return level;
    }
    void Print()
    {
        printf("--------------------------------------------------------\n");
        Node *cur = _head;
        while (cur)
        {
            printf("%d\n", cur->_val);
            // 打印每个每个cur节点
            for (auto e : cur->_nextArr)
            {
                printf("%2s ", "↓");
            }
            printf("\n");

            cur = cur->_nextArr[0];
        }
        printf("--------------------------------------------------------\n");
    }
};

模拟实现跳表 + 测试

#include <iostream>
#include <vector>
#include <ctime>
#include <random>
#include <chrono>
using namespace std;

struct SkiplistNode
{
    int _val;
    vector<SkiplistNode *> _nextArr;

    SkiplistNode(int val, int level)
        : _val(val), _nextArr(level, nullptr)
    {
    }
};

class Skiplist
{
    typedef SkiplistNode Node;

private:
    Node *_head;
    size_t _maxLevel = 32;
    double _p = 0.25;

public:
    Skiplist()
    {
        srand(time(0));

        // 头节点，层数是1
        _head = new Node(-1, 1);
    }

    bool search(int target)
    {
        Node *cur = _head;
        int level = _head->_nextArr.size() - 1;
        while (level >= 0)
        {
            // 目标值比下一个节点值要大，向右走
            // 下一个节点是空(尾)，目标值比下一个节点值要小，向下走
            if (cur->_nextArr[level] && cur->_nextArr[level]->_val < target)
            {
                // 向右走
                cur = cur->_nextArr[level];
            }
            else if (cur->_nextArr[level] == nullptr || cur->_nextArr[level]->_val > target)
            {
                // 向下走
                --level;
            }
            else
            {
                return true;
            }
        }

        return false;
    }

    vector<Node *> FindPrevNode(int num)
    {
        Node *cur = _head;
        int level = _head->_nextArr.size() - 1;

        // 插入位置每一层前一个节点指针
        vector<Node *> prevV(level + 1, _head);

        while (level >= 0)
        {
            // 目标值比下一个节点值要大，向右走
            // 下一个节点是空(尾)，目标值比下一个节点值要小，向下走
            if (cur->_nextArr[level] && cur->_nextArr[level]->_val < num)
            {
                // 向右走
                cur = cur->_nextArr[level];
            }
            else if (cur->_nextArr[level] == nullptr || cur->_nextArr[level]->_val >= num)
            {
                // 更新level层前一个
                prevV[level] = cur;

                // 向下走
                --level;
            }
        }

        return prevV;
    }

    void add(int num)
    {
        vector<Node *> prevArr = FindPrevNode(num);

        int n = RandomLevel();
        Node *newnode = new Node(num, n);

        // 如果n超过当前最大的层数，那就升高一下_head的层数
        if (n > _head->_nextArr.size())
        {
            _head->_nextArr.resize(n, nullptr);
            prevArr.resize(n, _head);
        }

        // 链接前后节点
        for (size_t i = 0; i < n; ++i)
        {
            newnode->_nextArr[i] = prevArr[i]->_nextArr[i];
            prevArr[i]->_nextArr[i] = newnode;
        }
    }

    bool erase(int num)
    {
        vector<Node *> prevV = FindPrevNode(num);

        // 第一层下一个不是val，val不在表中
        if (prevV[0]->_nextArr[0] == nullptr || prevV[0]->_nextArr[0]->_val != num)
        {
            return false;
        }
        else
        {
            Node *del = prevV[0]->_nextArr[0];
            // del节点每一层的前后指针链接起来
            for (size_t i = 0; i < del->_nextArr.size(); i++)
            {
                prevV[i]->_nextArr[i] = del->_nextArr[i];
            }
            delete del;

            // 如果删除最高层节点，把头节点的层数也降一下
            int i = _head->_nextArr.size() - 1;
            while (i >= 0)
            {
                if (_head->_nextArr[i] == nullptr)
                    --i;
                else
                    break;
            }
            _head->_nextArr.resize(i + 1);

            return true;
        }
    }

    int RandomLevel()
    {
        size_t level = 1;
        // rand() ->[0, RAND_MAX]之间
        while (rand() <= RAND_MAX * _p && level < _maxLevel)
        {
            ++level;
        }

        return level;
    }
    int RandomLevel2()
    {
        // 静态随机数生成器 只会在第一次调用该函数时被初始化
        // 生成器的种子是当前时间自纪元(1970年1月1日)以来的纳秒数
        static std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
        // 静态均匀分布对象 用于生成 [0.0, 1.0) 范围内的双精度浮点数
        static std::uniform_real_distribution<double> distribution(0.0, 1.0);

        size_t level = 1;
        while (distribution(generator) <= _p && level < _maxLevel)
        {
            ++level;
        }

        return level;
    }
    void Print()
    {
        printf("--------------------------------------------------------\n");
        Node *cur = _head;
        while (cur)
        {
            printf("%d\n", cur->_val);
            // 打印每个每个cur节点
            for (auto e : cur->_nextArr)
            {
                printf("%2s ", "↓");
            }
            printf("\n");

            cur = cur->_nextArr[0];
        }
        printf("--------------------------------------------------------\n");
    }
};

// 随即层数最大值 经测试是16
// int main()
// {
//     Skiplist sl;
//     int max = 0;
//     for (size_t i = 0; i < 1000000000; ++i)
//     {
//         //cout << sl.RandomLevel() <<" ";
//         int r = sl.RandomLevel();
//         if (r > max)
//             max = r;
//     }
//     cout << max << endl;

//     return 0;
// }

// 测试std随机数生成器
// int main()
// {
// 	unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
// 	std::default_random_engine generator(seed);

// 	std::uniform_real_distribution<double> distribution(0.0, 1.0);
// 	size_t count = 0;
// 	for (int i = 0; i < 100; ++i)
// 	{
// 		if (distribution(generator) <= 0.25)
// 			++count;
// 	}
// 	cout << count << endl;// 100次有17次生成的数小于等于0.25

// 	return 0;
// }

// 测试跳表
int main()
{
    Skiplist slist;
    // int a[] = { 5, 2, 3, 8, 9, 6, 5, 2, 3, 8, 9, 6, 5, 2, 3, 8, 9, 6 };
    int a[] = {3, 7, 11, 19, 22, 26, 37};
    for (auto e : a)
    {
        slist.add(e);
    }
    slist.Print();

    int x;
    cout << "请输入要删除的元素：";
    cin >> x;
    slist.erase(x);
    slist.Print();

    cout << "请输入要查找的元素：";
    cin >> x;
    if (slist.search(x))
        cout << "找到了" << endl;
    else
        cout << "没找到" << endl;
    cout << "请输入要查找的元素：";
    cin >> x;
    if (slist.search(x))
        cout << "找到了" << endl;
    else
        cout << "没找到" << endl;

    return 0;
}

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/911274.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

第一个纯血鸿蒙应用（Napi开发-ArtTS调用C/C++）

第一个纯血鸿蒙应用（Napi开发-ArtTS调用C/C++）

1.行业背景 纯血鸿蒙&#xff0c;即鸿蒙Next版已于2014年1月正式发版&#xff0c;鸿蒙生态设备数量已经突破10亿台&#xff0c;已经有超过15000个应用和元服务上架。鸿蒙生态不只是移动设备这么简单&#xff0c;他打造的是一个18n的全场景战略&#xff0c;真正做到了“万物互联…
阅读更多...
【从零开始的LeetCode-算法】3255. 长度为 K 的子数组的能量值 II

【从零开始的LeetCode-算法】3255. 长度为 K 的子数组的能量值 II

给你一个长度为 n 的整数数组 nums 和一个正整数 k 。 一个数组的 能量值 定义为&#xff1a; 如果 所有 元素都是依次 连续 且 上升 的&#xff0c;那么能量值为 最大 的元素。否则为 -1 。 你需要求出 nums 中所有长度为 k 的 子数组 的能量值。 请你返回一个长度为 n - …
阅读更多...
【Linux】进程创建/等待/替换相关知识详细梳理

【Linux】进程创建/等待/替换相关知识详细梳理

1. 进程创建 1.1 fork函数 概念&#xff1a;fork函数为系统调用接口&#xff0c;用于从已存在的进程中&#xff0c;创建一个新的进程。新进程为子进程&#xff0c;原来的进程为父进程。 用法&#xff1a; #include <unistd.h> pid_t fork(void); // 返回值&…
阅读更多...
CSS例子: 横向排列的格子

CSS例子: 横向排列的格子

效果 HTML <view class"content"><view class"item" v-for"item of 5">{{item}}</view></view> CSS .content {height: 100vh;display: flex;flex-direction: row; flex-wrap: wrap;align-content: flex-start;backgro…
阅读更多...
【机器学习】决定系数（R²：Coefficient of Determination）

【机器学习】决定系数（R²：Coefficient of Determination）

决定系数&#xff0c;也称为 R 平方&#xff0c;是一种用于衡量回归模型预测效果的统计指标。它表示了模型解释目标变量总变异的程度&#xff0c;数值介于 0 和 1 之间&#xff0c;数值越接近 1 表明模型的解释力越强。 1. 的定义和公式 的公式如下&#xff1a; 其中&#xf…
阅读更多...
[免费]SpringBoot+Vue(高校)学籍管理系统【论文+源码+SQL脚本】

[免费]SpringBoot+Vue(高校)学籍管理系统【论文+源码+SQL脚本】

大家好&#xff0c;我是java1234_小锋老师&#xff0c;看到一个不错的SpringBootVue(高校)学籍管理系统&#xff0c;分享下哈。 项目视频演示 【免费】SpringBootVue(高校)学籍管理系统 Java毕业设计_哔哩哔哩_bilibili 项目介绍 对在线学籍管理的流程进行科学整理、归纳和…
阅读更多...
＜项目代码＞YOLOv7 草莓叶片病害识别＜目标检测＞

＜项目代码＞YOLOv7 草莓叶片病害识别＜目标检测＞

YOLOv7是一种单阶段&#xff08;one-stage&#xff09;检测算法&#xff0c;它将目标检测问题转化为一个回归问题&#xff0c;能够在一次前向传播过程中同时完成目标的分类和定位任务。相较于两阶段检测算法&#xff08;如Faster R-CNN&#xff09;&#xff0c;YOLOv7具有更高的…
阅读更多...
Pinia小菠萝(状态管理器)

Pinia小菠萝(状态管理器)

Pinia 是一个专为 Vue 3 设计的状态管理库&#xff0c;它借鉴了 Vuex 的一些概念&#xff0c;但更加轻量灵活。下面将详细介绍如何使用 Pinia 状态管理库&#xff1a; 安装 Pinia 使用 npm&#xff1a;在项目目录下运行npm install pinia。使用 yarn&#xff1a;在项目目录下运…
阅读更多...
【深度学习】多分类任务评估指标sklearn和torchmetrics对比

【深度学习】多分类任务评估指标sklearn和torchmetrics对比

【深度学习】多分类任务评估指标sklearn和torchmetrics对比 说明sklearn代码torchmetrics代码两个MultiClassReport类的对比分析1. 代码结构与实现方式2. 数据处理与内存使用3. 性能与效率 二分类任务评估指标1. 准确率&#xff08;Accuracy&#xff09;2. 精确率&#xff08;P…
阅读更多...
[CUDA] 设置sync模式cudaSetDeviceFlags

[CUDA] 设置sync模式cudaSetDeviceFlags

文章目录 1. 设置cuda synchronize的等待模式2 设置函数3. streamQuery方式实现stream sync等待逻辑Reference 1. 设置cuda synchronize的等待模式 参考资料&#xff1a;https://docs.nvidia.com/cuda/pdf/CUDA_Runtime_API.pdf cuda的 synchronize等待模式分为&#xff1a; Y…
阅读更多...
jdk安装升级到jdk17

jdk安装升级到jdk17

百度安全验证 有些项目编译不过 找不到类 &#xff0c;实际有&#xff0c;需要升级jdk到17 https://blog.csdn.net/qq_44866828/article/details/130557027 sudo apt-get update sudo apt-get install openjdk-17-jdk 然后修改一下配置路径 也就是环境变量 11 改成17 重新…
阅读更多...
cuda、pytorch-gpu安装踩坑！！！

cuda、pytorch-gpu安装踩坑！！！

前提&#xff1a;已经安装了acanoda cuda11.6下载 直接搜索cuda11.6 acanoda操作 python版本3.9 conda create -n pytorch python3.9conda activate pytorch安装Pytorch-gpu版本等包 要使用pip安装&#xff0c;cu116cuda11.6版本 pip install torch1.13.1cu116 torchvi…
阅读更多...
H.265流媒体播放器EasyPlayer.js网页web无插件播放器：如何优化加载速度

H.265流媒体播放器EasyPlayer.js网页web无插件播放器：如何优化加载速度

在当今的网络环境中&#xff0c;用户对于视频播放体验的要求越来越高&#xff0c;尤其是对于视频加载速度的期待。EasyPlayer.js网页web无插件播放器作为一款专为现代Web环境设计的流媒体播放器&#xff0c;它在优化加载速度方面采取了多种措施&#xff0c;以确保用户能够享受到…
阅读更多...
C语言 | Leetcode C语言题解之第542题01矩阵

C语言 | Leetcode C语言题解之第542题01矩阵

题目&#xff1a; 题解&#xff1a; /*** Return an array of arrays of size *returnSize.* The sizes of the arrays are returned as *returnColumnSizes array.* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().*/ type…
阅读更多...
Transformer究竟是什么？预训练又指什么？BERT

Transformer究竟是什么？预训练又指什么？BERT

目录 Transformer究竟是什么？ 预训练又指什么？ BERT的影响力 Transformer究竟是什么？ Transformer是一种基于自注意力机制（Self-Attention Mechanism）的神经网络架构，它最初是为解决机器翻译等序列到序列（Seq2Seq）任务而设计的。与传统的循环神经网络（RNN）或卷…
阅读更多...
【春秋云镜】CVE-2023-23752

【春秋云镜】CVE-2023-23752

目录 CVE-2023-23752漏洞细节漏洞利用示例修复建议 春秋云镜&#xff1a;解法一&#xff1a;解法二&#xff1a; CVE-2023-23752 是一个影响 Joomla CMS 的未授权路径遍历漏洞。该漏洞出现在 Joomla 4.0.0 至 4.2.7 版本中&#xff0c;允许未经认证的远程攻击者通过特定 API 端…
阅读更多...
51单片机教程（七）- 蜂鸣器

51单片机教程（七）- 蜂鸣器

1 项目分析 利用P2.3引脚输出电平变化&#xff0c;控制蜂鸣器的鸣叫。 2 技术准备 1 蜂鸣器介绍 有绿色电路板的一种是无源蜂鸣器&#xff0c;没有电路板而用黑胶封闭的一种是有源蜂鸣器。 有源蜂鸣器和无源蜂鸣器 这里的“源”不是指电源。而是指震荡源。也就是说有源蜂鸣…
阅读更多...
十六 MyBatis使用PageHelper

十六 MyBatis使用PageHelper

十六、MyBatis使用PageHelper 16.1 limit分页 mysql的limit后面两个数字&#xff1a; 第一个数字&#xff1a;startIndex&#xff08;起始下标。下标从0开始。&#xff09;第二个数字&#xff1a;pageSize&#xff08;每页显示的记录条数&#xff09; 假设已知页码pageNum&…
阅读更多...
汽车和飞机研制过程中“骡车”和“铁鸟”

汽车和飞机研制过程中“骡车”和“铁鸟”

在汽车和飞机的研制过程中&#xff0c;“骡车”和“铁鸟”都扮演着至关重要的角色。 “骡车”在汽车研制中&#xff0c;是一种处于原型车和量产车之间的过渡阶段产物。它通常由不同的零部件组合而成&#xff0c;就像骡子是马和驴的杂交后代一样&#xff0c;取各家之长。“骡车…
阅读更多...
MySQL存储目录与配置文件(ubunto下)

MySQL存储目录与配置文件(ubunto下)

mysql的配置文件&#xff1a; 在这个目录下&#xff0c;直接cd /etc/mysql/mysql.conf.d mysql的储存目录&#xff1a; /var/lib/mysql Ubuntu版本号&#xff1a;
阅读更多...
最新文章

Copyright @ 2022~2023