数据结构和算法笔记5：堆和优先队列

news2024/11/15 23:55:02

今天来讲一下堆，在网上看到一个很好的文章，不过它实现堆是用Golang写的，我这里打算用C++实现一下：

Golang: Heap data structure

1. 基本概念

  • 满二叉树（二叉树每层节点都是满的）：

在这里插入图片描述

  • 完全二叉树：叶子节点只出现在最后一层或倒数第二层，并且节点都是向左聚拢
  • 非完全二叉树：下面的二叉树不满足完全二叉树的节点都向左聚拢，所以是非完全二叉树

在这里插入图片描述

堆也是一颗完全二叉树。

  • 小顶堆：根节点是最小值，并且子节点大于等于父节点
  • 大顶堆：根节点是最大值，并且子节点小于等于父节点
    在这里插入图片描述

由于树的特性，堆可以用数组索引的形式表示，以小顶堆为例，在下面的小顶堆里，依次从上到下从左往右给节点编号，根节点的编号是0,：

在这里插入图片描述

对应的数组为：

在这里插入图片描述
对比数组和堆，堆的索引有以下的性质：

  1. 根节点索引是0
  2. 若当前节点索引为i，如果它有父节点，父节点的索引是(i-1)/2（C++向下取整）
  3. 若当前节点索引为i，如果它有左节点，左节点的索引是2*i+1，如果它有右节点，右节点的索引是2*i+2
  4. 设数组的长度为len，最后一个非叶子节点的索引是(len-2)/2，比如上面的K是9，最后一个非叶子节点的索引是(9-2)/2=3
    在这里插入图片描述

2. 堆的基本操作

C++有heapn内置函数来实现，具体看c++重拾 STL之heap（堆）。这里我们讲解原理，下面以小顶堆为例描述堆的相关操作

2.0 交换节点操作

我们先定义交换节点的操作，为后面调整为堆做准备：

void HeapSwap(vector<int> &minHeap, int curIndex, int swapIndex)
{
    int t = minHeap[curIndex];
    minHeap[curIndex] = minHeap[swapIndex];
    minHeap[swapIndex] = t;
}

2.1 下浮操作

下浮操作是通过下浮的方式把一个完全二叉树调整为堆，具体的步骤是将它与它的左儿子，右儿子比较大小，如果不满足小顶堆的性质（当前节点的值大于等于左右孩子的节点的值），当前节点需要与左右孩子的最小值节点交换位置（否则不满足堆的性质），递归的完成这个过程。（时间复杂度是log(n)）

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
我们定义一个swapIndex，记录需要交换调整的节点索引，如果需要调整，这个索引是当前节点和左右子节点索引的最小值，这个过程要注意判断边界条件：

void HeapSiftDown(vector<int> &minHeap, int curIndex)
{
    int leftChildIndex = 2 * curIndex + 1;  // 左孩子节点的索引
    int rightChildIndex = 2 * curIndex + 2; // 右孩子节点的索引
    int swapIndex = curIndex;               // 定义调整的节点索引

    // 判断左右孩子是否小于当前元素，如果是把swapIndex赋值为孩子索引
    if (leftChildIndex < minHeap.size() && minHeap[leftChildIndex] < minHeap[swapIndex])
        swapIndex = leftChildIndex;
    if (rightChildIndex < minHeap.size() && minHeap[rightChildIndex] < minHeap[swapIndex])
        swapIndex = rightChildIndex;

    // 判断交换索引和当前索引是不是一样，如果不一样说明要交换，然后继续SiftDown，直到到最后一个节点
    if (curIndex != swapIndex)
    {
        HeapSwap(minHeap, curIndex, swapIndex);
        HeapSiftDown(minHeap, swapIndex);
    }
}

2.2 上浮操作

上浮操作是通过上浮的方式把一个完全二叉树调整为堆，具体的步骤是将它与它的父亲节点比较大小，如果不满足小顶堆的性质（父亲的节点的值大于等于当前节点的值），当前节点与父亲节点交换位置（否则不满足堆的性质），递归的完成这个过程。（时间复杂度是log(n)）

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
我们类似上浮操作定义一个swapIndex，记录需要交换调整的节点索引，如果需要调整，这个索引是父亲节点的索引，这个过程要注意判断边界条件：

void HeapSiftUp(vector<int> &minHeap, int curIndex)
{
    int parentIndex = (curIndex - 1) / 2;//父亲节点的索引
    int swapIndex = curIndex;// 定义调整的节点索引

	// 判断左右孩子是否小于当前元素，如果是把swapIndex赋值为孩子索引
    if (parentIndex >= 0 && minHeap[curIndex] < minHeap[parentIndex])
        swapIndex = parentIndex;
    // 判断交换索引和当前索引是不是一样，如果不一样说明要交换，然后继续SiftUp，直到到最后一个节点
    if (curIndex != swapIndex)
    {
        HeapSwap(minHeap, curIndex, swapIndex);
        HeapSiftUp(minHeap, swapIndex);
    }
}

2.3 给定一个数组建堆

建堆有上浮和下浮两种方法：

如果是下浮的方法，可以直接从最后一个不是叶节点的节点开始往上下浮（叶子节点没有左右孩子一定不需要交换）。这里使用了前面堆索引性质的第四条：

设数组的长度为len，最后一个非叶子节点的索引是(len-2)/2

void HeapBuild(vector<int> &array)
{
    int lastNoLeafIndex = (array.size() - 2) / 2;
    for (int i = lastNoLeafIndex; i >= 0; i--)//从最后一个不是叶节点的节点开始往上下浮
        HeapSiftDown(array, i);
}

如果是上浮的方法，则从索引为1节点开始往下上浮（根节点没有父亲节点一定不需要交换）。

void HeapBuild(vector<int> &array)
{
    for (int i = 1; i < array.size(); ++i)//从索引为1节点开始往下上浮
        HeapSiftUp(array, i);
}

使用下浮建堆的时间复杂度是O(n)，而使用上浮建堆的时间复杂度是O(nlogn)，建议使用下浮建堆。关于复杂度参考How can building a heap be O(n) time complexity?
在这里插入图片描述

2.4 Pop操作

pop操作是把根节点弹出返回，并重新调整剩余元素构成的数组为堆，数组的长度为len，这里我们把根节点和最后一个节点交换，中间要保留根节点的值，然后把数组调整为len-1（因为弹出一个元素了），重新用下浮调整为堆，然后返回堆的根节点的值。时间复杂度是log(n)

int HeapPop(vector<int> &minHeap)
{
    int value = minHeap[0];//保留堆的根节点的值
    int len = minHeap.size();//记录堆的大小
    HeapSwap(minHeap, 0, len - 1);//把堆的根节点和最后一个节点交换
    minHeap.resize(len - 1);//调整数组长度为len-1
    HeapSiftDown(minHeap, 0);//下浮调整为堆
    return value;//返回堆的根节点的值
}

2.5 Push操作

push操作是在数组末尾加入元素num，然后重新调整成堆。相比pop操作，push操作就简单很多了，我们先在数组末尾加入元素num，然后从最后一个元素的索引开始使用上浮即可。时间复杂度是log(n)

void HeapPush(vector<int> &minHeap, int num)
{
    minHeap.push_back(num);//在数组末尾加入元素num
    HeapSiftUp(minHeap, minHeap.size() - 1);//从最后一个元素的索引开始使用上浮
}

测试：

完整代码：

#include <iostream>
#include <vector>
using namespace std;

void HeapSiftDown(vector<int> &minHeap, int curIndex);
void HeapSiftUp(vector<int> &minHeap, int curIndex);
void HeapSwap(vector<int> &minHeap, int curIndex, int swapIndex);
void HeapBuild(vector<int> &array);
void HeapPush(vector<int> &minHeap, int num);

void HeapBuild(vector<int> &array)
{
    int lastNoLeafIndex = (array.size() - 2) / 2;
    for (int i = lastNoLeafIndex; i >= 0; i--)
        HeapSiftDown(array, i);
}

void HeapSiftDown(vector<int> &minHeap, int curIndex)
{
    int leftChildIndex = 2 * curIndex + 1; 
    int rightChildIndex = 2 * curIndex + 2;
    int swapIndex = curIndex;               

    if (leftChildIndex < minHeap.size() && minHeap[leftChildIndex] < minHeap[swapIndex])
        swapIndex = leftChildIndex;
    if (rightChildIndex < minHeap.size() && minHeap[rightChildIndex] < minHeap[swapIndex])
        swapIndex = rightChildIndex;

    if (curIndex != swapIndex)
    {
        HeapSwap(minHeap, curIndex, swapIndex);
        HeapSiftDown(minHeap, swapIndex);
    }
}

void HeapSiftUp(vector<int> &minHeap, int curIndex)
{
    int parentIndex = (curIndex - 1) / 2;
    int swapIndex = curIndex;
    if (parentIndex >= 0 && minHeap[curIndex] < minHeap[parentIndex])
        swapIndex = parentIndex;

    if (curIndex != swapIndex)
    {
        HeapSwap(minHeap, curIndex, swapIndex);
        HeapSiftUp(minHeap, swapIndex);
    }
}
void HeapSwap(vector<int> &minHeap, int curIndex, int swapIndex)
{
    int t = minHeap[curIndex];
    minHeap[curIndex] = minHeap[swapIndex];
    minHeap[swapIndex] = t;
}

int HeapPop(vector<int> &minHeap)
{
    int value = minHeap[0];
    int len = minHeap.size();
    HeapSwap(minHeap, 0, len - 1);
    minHeap.resize(len - 1);
    HeapSiftDown(minHeap, 0);
    return value;
}

void HeapPush(vector<int> &minHeap, int num)
{
    minHeap.push_back(num);
    HeapSiftUp(minHeap, minHeap.size() - 1);
}

int main()
{
    vector<int> array{9, 31, 40, 22, 10, 15, 1, 25, 91};
    cout << "The origin array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    cout << endl
         << "---------------------------------------------------" << endl;

    // 建堆
    HeapBuild(array);
    cout << "After build the heap, the array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    cout << endl
         << "---------------------------------------------------" << endl;

    // pop元素
    int top = HeapPop(array);
    cout << "The pop value is " << top << endl;
    cout << "After pop, the array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    cout << endl
         << "---------------------------------------------------" << endl;

    // push元素
    HeapPush(array, 1);
    cout << "After push, the array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    cout << endl
         << "---------------------------------------------------" << endl;
}

在这里插入图片描述

可以自行印证上面满足小顶堆。大顶堆的思路和小顶堆的思路差不多。读者可以自己实现一下。

3. 堆的相关使用

3.1 堆排序

堆排序基本的思路是：

  1. 初始化：数组建堆
  2. 数组的根节点和堆的最后一个节点交换
  3. 剩余元素重新排成堆（堆的长度减1），然后继续第2步操作直到数组的长度为1

这里也放一个算法导论的截图（不过它的根节点的索引是1），思路是差不多的：

在这里插入图片描述

我们这里使用小顶堆，小顶堆的根节点是最小值，每次第2步和后面的节点做交换，所以最后排序是从大到小（最小值根节点都放到数组的后面）。

前面的建堆是对整个数组来说的，但是对于堆排序，我们需要划定要排序数组的范围，所以我们对建堆和下浮两个操作另外定义一个函数：

  • HeapSiftDown函数

注意这里的数组越界处理改为了传入的heapLength，我们只需要对0-heapLength-1范围的数组做下浮的操作

void HeapSiftDown(vector<int> &minHeap, int curIndex, int heapLength)
{
    int leftChildIndex = 2 * curIndex + 1;  // 左孩子节点的索引
    int rightChildIndex = 2 * curIndex + 2; // 右孩子节点的索引
    int swapIndex = curIndex;               // 定义和当前索引交换的索引

    // 判断左右孩子是否小于当前元素，如果是把swapIndex换给孩子索引，注意这里的数组越界处理改为了传入的heapLength 
    if (leftChildIndex < heapLength && minHeap[leftChildIndex] < minHeap[swapIndex])
        swapIndex = leftChildIndex;
    if (rightChildIndex < heapLength && minHeap[rightChildIndex] < minHeap[swapIndex])
        swapIndex = rightChildIndex;

    // 判断交换索引和当前索引是不是一样，如果不一样说明要交换，继续SiftDown，直到到最后一个节点
    if (curIndex != swapIndex)
    {
        HeapSwap(minHeap, curIndex, swapIndex);
        HeapSiftDown(minHeap, swapIndex, heapLength);
    }
}
  • HeapBuild函数

注意这里的计算最后一个非叶子节点的索引使用了传入的heapLength，相当于对0-heapLength-1范围的数组建堆

void HeapBuild(vector<int> &array, int heapLength)
{
    int lastNoLeafIndex = (heapLength - 2) / 2;//注意这里最后一个非叶子节点的索引使用的是传入的heapLength
    for (int i = lastNoLeafIndex; i >= 0; i--)
        HeapSiftDown(array, i, heapLength);
}

OK我们可以写堆排序了，传入一个数组：

void HeapSort(vector<int> &array)
{
    int heapLength = array.size();//建堆的长度
    int len = array.size();//数组的长度
    HeapBuild(array, heapLength);
    for (int i = len - 1; i >= 1; --i)//遍历到索引1就行，索引0不需要遍历，因为只有一个数了
    {
        HeapSwap(array, 0, i);//把索引0（根节点）和索引i节点交换
        heapLength--;//建堆的长度减1
        HeapBuild(array, heapLength);//再次对0~heapLength-1的数组建堆
    }
}

测试堆排序

#include <iostream>
#include <vector>
using namespace std;
void HeapBuild(vector<int> &array, int heapLength);
void HeapSort(vector<int> &array);

void HeapBuild(vector<int> &array, int heapLength)
{
    int lastNoLeafIndex = (heapLength - 2) / 2;//注意这里最后一个非叶子节点的索引使用的是传入的heapLength
    for (int i = lastNoLeafIndex; i >= 0; i--)
        HeapSiftDown(array, i, heapLength);
}
void HeapSort(vector<int> &array)
{
    int heapLength = array.size();//建堆的长度
    int len = array.size();//数组的长度
    HeapBuild(array, heapLength);
    for (int i = len - 1; i >= 1; --i)//遍历到索引1就行，索引0不需要遍历，因为只有一个数了
    {
        HeapSwap(array, 0, i);//把索引0（根节点）和索引i节点交换
        heapLength--;//建堆的长度减1
        HeapBuild(array, heapLength);//再次对0~heapLength-1的数组建堆
    }
}
int main()
{
    vector<int> array{9, 31, 40, 22, 10, 15, 1, 25, 91};
    cout << "The origin array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    cout << endl
         << "---------------------------------------------------" << endl;


    // sort元素
    HeapSort(array);
    cout << "After sort, the array is " << endl;
    for (auto &t : array)
        cout << t << " ";
    return 0;
}

可以看到从大到小进行了排序，如果用大顶堆，就是从小到大排序。
在这里插入图片描述

3.2 优先队列

优先级队列虽然也叫队列，但是和普通的队列还是有差别的。普通队列出队顺序只取决于入队顺序，而优先级队列的出队顺序总是按照元素自身的优先级。可以理解为，优先级队列是一个排序后的队列。

堆和优先级队列非常相似，一个堆就可以看作一个优先级队列。往优先级队列中插入一个元素，就相当于往堆中插入一个元素；从优先级队列中取出优先级最高的元素，就相当于取出堆顶元素（大顶堆–最大值；小顶堆–最小值）。不过优先级我们还可以自己额外定义。C++有priority_queue来实现，具体可以看c++优先队列(priority_queue)用法详解。

所以优先队列有两个操作，分别是pop弹出和push加入，pop即弹出根节点，push即把新的元素加入优先队列，两种操作过后要保证剩余的元素构成的还是一个堆。直接使用前面所说的pop和push操作即可。

4. 典型例题

347. 前 K 个高频元素

在这里插入图片描述
前K个元素，先用哈希表记录元素的频率，然后可以使用小根堆，如果队列元素超过K可以弹出根节点（最小的元素），遍历完以后，队列里剩下的就是前K大的元素。

class Solution {
public:
    static bool cmp(pair<int, int>& a, pair<int, int>& b)
    {
        return a.second > b.second;
    }
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> ans;
        unordered_map<int, int> mp;
        for (auto& t: nums)
            mp[t]++;
        priority_queue<pair<int, int>, vector<pair<int, int>>, decltype(&cmp)> que(cmp);
        for (auto it = mp.begin(); it != mp.end(); ++it)
        {
            que.push(*it);
            if (que.size() > k)
                que.pop();
        }
        while (!que.empty())
        {
            ans.push_back(que.top().first);
            que.pop();
        }
        return ans;
    }
};

关于priority_queue的比较函数cmp也可以使用仿函数：

class Solution {
public:
    class cmp {
    public:
        bool operator() (const pair<int, int> &lhs, const pair<int, int> &rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> ans;
        unordered_map<int, int> mp;
        for (auto& t: nums)
            mp[t]++;
        priority_queue<pair<int, int>, vector<pair<int, int>>, cmp> que;
        for (auto it = mp.begin(); it != mp.end(); ++it)
        {
            que.push(*it);
            if (que.size() > k)
                que.pop();
        }
        while (!que.empty())
        {
            ans.push_back(que.top().first);
            que.pop();
        }
        return ans;
    }
};

内置类型比如int的话cmp可以直接使用greater<int>（小根堆）和less<int>（大根堆），如果比较自定义的Node类型，可以在Node里重载<：

#include <queue>
#include <iostream>
using namespace std;
struct Node
{
    int x, y;
    bool operator<(const Node &rhs) const
    {
        return this->x > rhs.x; // 用x比较，这里是>，是小根堆
    }
};
int main()
{
    priority_queue<Node> que;
    que.push(Node{1, 2});
    que.push(Node{2, 1});
    que.push(Node{4, 2});
    while (!que.empty())
    {
        cout << que.top().x << " " << que.top().y << endl;
        que.pop();
    }
}

在这里插入图片描述

215. 数组中的第K个最大元素

和上题类似，我们使用一个小顶堆，遍历完整个数组，最后剩下的根节点就是第K大元素了。

class Solution {
public:

    int findKthLargest(vector<int>& nums, int k) {
        priority_queue<int, vector<int>, greater<int>> que;
        for (auto& t:nums)
        {
            que.push(t);
            if (que.size() > k)
            {
                que.pop();
            }
        }
        return que.top();
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

java中aes加密解密工具类

java中aes加密解密工具类

java中aes加密解密工具类 字符串&#xff1a;{“DATA”:{“SJH”:“17600024168”,“DLZH”:“91510104MA67FPXR5T”,“DLMM”:“jhdz123456”,“DLSF”:“5”,“NSRSBH”:“91510104MA67FPXR5T”},“JRSF”:“23”} 加密后&#xff1a;y4mzmi3jta22aXeIPfEdzu8sgA9uy3OevaIY…
阅读更多...
【Midjourney】内容展示风格关键词

【Midjourney】内容展示风格关键词

1.几何排列(Geometric) "Geometric" 是一个与几何有关的词汇&#xff0c;通常用于描述与形状、结构或空间几何特征相关的事物。这个词可以涉及数学、艺术、工程、计算机图形学等多个领域。 使用该关键词后&#xff0c;图片中的内容会以平面图形拼接的方式展示&#…
阅读更多...
优雅的python（二）

优雅的python（二）

&#x1f308;个人主页&#xff1a;小田爱学编程 &#x1f525; 系列专栏&#xff1a;c语言从基础到进阶 &#x1f3c6;&#x1f3c6;关注博主&#xff0c;随时获取更多关于c语言的优质内容&#xff01;&#x1f3c6;&#x1f3c6; &#x1f600;欢迎来到小田代码世界~ &#x…
阅读更多...
【机器学习】强化学习（八）-深度确定性策略梯度（DDPG）算法及LunarLanderContinuous-v2环境训练示例...

【机器学习】强化学习（八）-深度确定性策略梯度（DDPG）算法及LunarLanderContinuous-v2环境训练示例...

训练效果 DDPG算法是一种基于演员-评论家&#xff08;Actor-Critic&#xff09;框架的深度强化学习&#xff08;Deep Reinforcement Learning&#xff09;算法&#xff0c;它可以处理连续动作空间的问题。DDPG算法描述如下&#xff1a; GPT-4 Turbo Copilot GPT-4 DDPG算法伪代…
阅读更多...
Adobe ColdFusion 任意文件读取漏洞复现（CVE-2023-26361）

Adobe ColdFusion 任意文件读取漏洞复现（CVE-2023-26361）

0x01 产品简介 Adobe ColdFusion是美国奥多比（Adobe）公司的一套快速应用程序开发平台。该平台包括集成开发环境和脚本语言。 0x02 漏洞概述 Adobe ColdFusion平台 filemanager.cfc接口存在任意文件读取漏洞，攻击者可通过该漏洞读取系统重要文件（如数据库配置文件、系统配…
阅读更多...
vue3框架基本使用

vue3框架基本使用

一、安装包管理工具 vite和vue-cli一样&#xff0c;都是脚手架。 1.node版本 PS E:\vuecode\vite1> node -v v18.12.12.安装yarn工具 2.1 yarn简单介绍 yarn是一个包管理工具&#xff0c;也是一个构建、打包工具 yarn需要借助npm进行安装&#xff1a;执行的命令行npm i…
阅读更多...
React一学就会(3): 强化练习一

React一学就会(3): 强化练习一

前言 兄弟们点个关注点点赞&#xff0c;有什么建议在评论里留言说一下&#xff0c;一定要和我多多互动啊&#xff0c;这样我才有动力创作出更有品质的文章。 这节课我们用前两节课的知识做一个实践&#xff0c;在实战中巩固我们所学。本来我想借用官方的示例翻译一下&#xf…
阅读更多...
认识思维之熵

认识思维之熵

经常有读者问我&#xff0c;说&#xff1a; 为什么向您请教一个问题&#xff0c;您总能很快指出在哪篇文章里面提到过&#xff0c;是因为您的记忆力特别好吗&#xff1f; 其实不是的。更重要的原因是&#xff1a;如果你经过系统训练&#xff0c;有意识地去获取知识的话&#x…
阅读更多...
JVM篇----第九篇

JVM篇----第九篇

系列文章目录 文章目录 系列文章目录前言一、分代收集算法二、新生代与复制算法三、老年代与标记复制算法前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。 一、分代…
阅读更多...
PageHelper学习使用

PageHelper学习使用

基于mybatis源码和PageHelper源码进行的测试 版本 mybatis3.5.0&#xff0c;pageHelper6.0.0 测试用例 依赖 <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.15</version> &…
阅读更多...
权威媒体报道 | 百分点科技谈“数据要素×”

权威媒体报道 | 百分点科技谈“数据要素×”

近日&#xff0c;国家数据局等17部门联合印发《“数据要素”三年行动计划&#xff08;2024—2026年&#xff09;》&#xff0c;引起广泛关注&#xff0c;作为数据要素技术厂商代表&#xff0c;百分点科技CTO刘译璟接受经济日报、中国高新技术产业导报采访&#xff0c;结合产业现…
阅读更多...
pysot中eval多种算法比较和画图

pysot中eval多种算法比较和画图

安装miktex和Texwork&#xff0c;记得更新miktex&#xff0c;链接https://miktex.org/download&#xff0c; 参考https://blog.csdn.net/weixin_42495721/article/details/110855071 我用的是pysot官方的库&#xff0c;里面包括eval和test、train等py文件。 路径结构为&#x…
阅读更多...
【C++修行之道】STL（初识list、stack）

【C++修行之道】STL（初识list、stack）

目录 一、list 1.1list的定义和结构 以下是一个示例&#xff0c;展示如何使用list容器: 1.2list的常用函数 1.3list代码示例 二、stack 2.1stack的定义和结构 stack的常用定义 2.2常用函数 2.3stack代码示例 一、list 1.1list的定义和结构 list的使用频率不高&#…
阅读更多...
【JAVA】什么是自旋

【JAVA】什么是自旋

&#x1f34e;个人博客&#xff1a;个人主页 &#x1f3c6;个人专栏&#xff1a;JAVA ⛳️ 功不唐捐&#xff0c;玉汝于成 目录 前言 正文 结语 我的其他博客 前言 在计算机科学的领域中&#xff0c;多线程和并发编程已成为处理复杂任务和提高系统性能的不可或缺的手段。…
阅读更多...
行测-言语：3.逻辑填空

行测-言语：3.逻辑填空

行测-言语&#xff1a;3.逻辑填空&#xff08;刷题积累&#xff0c;国考省考&#xff09; 1. 词的辨析 1.1 词义侧重 C&#xff0c;心酸&#xff1a;内心难过&#xff1b;辛酸&#xff1a;辛苦&#xff1b;刻画&#xff1a;雕刻和绘画&#xff1b;塑造&#xff1b;描绘&#x…
阅读更多...
MC3172 初探

MC3172 初探

感芯科技第一款32位 RISC处理器MC3172&#xff0c;业内首个64线程同步并行运行&#xff0c;线程资源可按需配置&#xff0c; 共享代码段空间与数据段空间&#xff0c;硬件级实时响应&#xff0c;无需中断服务程序&#xff0c;无需实时操作系统。 基于RISC-V RV32IMC 指令集&…
阅读更多...
STM32实现软件IIC协议操作OLED显示屏（2）

STM32实现软件IIC协议操作OLED显示屏（2）

时间记录&#xff1a;2024/1/27 一、OLED相关介绍 &#xff08;1&#xff09;显示分辨率128*64点阵 &#xff08;2&#xff09;IIC作为从机的地址0x78 &#xff08;3&#xff09;操作步骤&#xff1a;主机先发送IIC起始信号S&#xff0c;然后发送OLED的地址0x78&#xff0c;然…
阅读更多...
java servlet运输公司管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

java servlet运输公司管理系统Myeclipse开发mysql数据库web结构java编程计算机网页项目

一、源码特点 java Web运输公司管理系统是一套完善的java web信息管理系统 serlvetdaobean mvc 模式开发 &#xff0c;对理解JSP java编程开发语言有帮助&#xff0c;系统具有完整的源代码和数据库&#xff0c;系统主 要采用B/S模式开发。开发环境为TOMCAT7.0,Myeclipse8.5…
阅读更多...
Linux服务器配置与管理（第二次实验）

Linux服务器配置与管理（第二次实验）

实验目的及具体要求 目的 1.掌握基于命令行的文件操作 2.掌握基于命令行的目录操作 3.掌握用户账户的命令行操作 4.掌握组账户的命令行操作 5.熟悉磁盘分区操作 6.掌握调整优先级的方法 具体要求 1.掌握基于命令行的文件和目录操作 ①创建测试目录 ②创建文件 ③复…
阅读更多...
3DGS 其二：Street Gaussians for Modeling Dynamic Urban Scenes

3DGS 其二：Street Gaussians for Modeling Dynamic Urban Scenes

3DGS 其二&#xff1a;Street Gaussians for Modeling Dynamic Urban Scenes 1. 背景介绍1.1 静态场景建模1.2 动态场景建模 2. 算法2.1 背景模型2.2 目标模型 3. 训练3.1 跟踪优化 4. 下游任务 Reference&#xff1a; Street Gaussians for Modeling Dynamic Urban Scenes 1.…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023