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

今天来讲一下堆，在网上看到一个很好的文章，不过它实现堆是用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-1HeapSiftDown(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);//在数组末尾加入元素numHeapSiftUp(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;//注意这里最后一个非叶子节点的索引使用的是传入的heapLengthfor (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--;//建堆的长度减1HeapBuild(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;//注意这里最后一个非叶子节点的索引使用的是传入的heapLengthfor (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--;//建堆的长度减1HeapBuild(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.mzph.cn/news/650628.shtml

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

相关文章

微信小程序（十二）在线图标与字体的获取与引入

微信小程序（十二）在线图标与字体的获取与引入

注释很详细&#xff0c;直接上代码 上一篇 新增内容&#xff1a; 1.从IconFont获取图标与文字的样式链接 2.将在线图标配置进页面中&#xff08;源码&#xff09; 3.将字体配置进页面文字中&#xff08;源码&#xff09; 4.css样式的多文件导入 获取链接 1.获取图标链接 登入…
阅读更多...
ABAP 状态栏排除某些按钮

ABAP 状态栏排除某些按钮

ABAP 状态栏排除某些按钮 GUI State状态栏 在状态栏这里有这些按钮&#xff0c;现在在导出界面要排除掉这些按钮&#xff1a; 将要排除的按钮追加到gt_code内表&#xff1a; gt_fcode功能码内表的定义 DATA:gt_fcode TYPE TABLE OF sy-ucomm,完整程序 *&---------…
阅读更多...
tomcat、mysql连接数配置

tomcat、mysql连接数配置

&#xff08;1&#xff09;springboot tomcat连接数配置 server.tomcat.max-connections10000&#xff0c;最大被连接数&#xff0c;默认10000 server.tomcat.accept-count100&#xff0c;等待队列长度&#xff0c;默认100 server.tomcat.max-threads200&#xff0c;最大的工作…
阅读更多...
上位机图像处理和嵌入式模块部署（python opencv）

上位机图像处理和嵌入式模块部署（python opencv）

【 声明&#xff1a;版权所有&#xff0c;欢迎转载&#xff0c;请勿用于商业用途。 联系信箱&#xff1a;feixiaoxing 163.com】 前面我们谈到了qt&#xff0c;谈到了opencv&#xff0c;也谈到了嵌入式&#xff0c;但是没有说明python在这个过程当中应该扮演什么样的角色。open…
阅读更多...
【Linux】Linux进程间通信

【Linux】Linux进程间通信

Linux进程间通信 一、进程间通信介绍1、概念2、进程间通信目的3、进程间通信的本质4、进程间通信分类 二、管道1、什么是管道2、匿名管道&#xff08;1&#xff09;匿名管道原理&#xff08;2&#xff09;pipe函数&#xff08;3&#xff09;匿名管道的使用步骤i、父进程调用pip…
阅读更多...
Frontend - SASS / SCSS 文件使用

Frontend - SASS / SCSS 文件使用

目录 一、安装所需依赖 1. django-compressor 2. django-sass-processor 二、settings.py 文件配置 三、html使用 1. 配置 2. 导入 一、安装所需依赖 1. django-compressor 2. django-sass-processor 安装依赖&#xff0c;可参考另一篇文章&#xff1a;Backend - 安…
阅读更多...
【汇总】解决Spring-Web与Spring-WebFlux冲突

【汇总】解决Spring-Web与Spring-WebFlux冲突

【汇总】解决Spring-Web与Spring-WebFlux冲突 问题发现问题解决问题一&#xff1a;The bean requestMappingHandlerMapping, defined in class path resource [org/springframework/web/reactive/config/DelegatingWebFluxConfiguration.class],问题二&#xff1a;The Java/XML…
阅读更多...
贝叶斯增量式跨域适应：少样本 + 跨模态学习 + 知识保留和推断【fundus + OCT】，做视网膜病变

贝叶斯增量式跨域适应：少样本 + 跨模态学习 + 知识保留和推断【fundus + OCT】，做视网膜病变

贝叶斯深度学习&#xff1a;增量式少样本学习跨域适应 贝叶斯多目标函数 跨模态学习 fundus OCT&#xff0c;做视网膜病变 核心思想设计网络&#xff1a;寻找分类模型、损失函数实验结果混淆矩阵与注意力图评估 总结 核心思想 论文&#xff1a;https://arxiv.org/pdf/2110.…
阅读更多...
数学建模-------误差来源以及误差分析

数学建模-------误差来源以及误差分析

绝对误差&#xff1a;精确值-近似值&#xff1b; 举个例子&#xff1a;从A到B&#xff0c;应该有73千米&#xff0c;但是我们近似成了70千米&#xff1b;从C到D&#xff0c;应该是1373千米&#xff0c;我们近似成了1370千米&#xff0c;如果使用绝对误差&#xff0c;结果都是3…
阅读更多...
代码随想录算法训练营第32天 | 122.买卖股票的最佳时机II + 55. 跳跃游戏 + 45.跳跃游戏II

代码随想录算法训练营第32天 | 122.买卖股票的最佳时机II + 55. 跳跃游戏 + 45.跳跃游戏II

今日任务 122.买卖股票的最佳时机II 55. 跳跃游戏 45.跳跃游戏II 122.买卖股票的最佳时机II - Medium 题目链接&#xff1a;力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 给你一个整数数组 prices &#xff0c;其中 prices[i] 表示某支股票第 i…
阅读更多...
关于前端脚手架的依赖升级和去风险版本可能遇到的问题

关于前端脚手架的依赖升级和去风险版本可能遇到的问题

一、升级依赖版本 1、检查过时依赖 npm outdated 2、根据具体情况&#xff0c;选择安全更新或全部更新到最新版本 2.1 安全更新&#xff08;不破坏依赖间的联系&#xff09; npm update 2.2 全部更新到最新版本 首先输入命令&#xff1a; npx npm-check-updates -u 执…
阅读更多...
订单系统设计与营销系统整合的全面探讨

订单系统设计与营销系统整合的全面探讨

在电商领域&#xff0c;订单系统的设计至关重要&#xff0c;涉及到用户体验、营销费用分摊、以及各种参数的校验。本文将从多个角度深入探讨订单系统的设计&#xff0c;包括与营销系统的整合、营销费用分摊&#xff0c;以及下单前的各种参数校验。 1. 订单系统与营销系统整合 …
阅读更多...
算法训练营Day58（单调栈1）

算法训练营Day58（单调栈1）

说明 单调栈适合寻找一个元素左边或右边第一个比自己大或小的元素 其作用是用力存放之前遍历过的元素 单调递减的栈是求比其小的元素 单调递增的栈是求比其大的元素 739. 每日温度 力扣&#xff08;LeetCode&#xff09;官网 - 全球极客挚爱的技术成长平台 提醒 今天正式开…
阅读更多...
在 ASP.NET Core Web API 中使用操作筛选器统一处理通用操作

在 ASP.NET Core Web API 中使用操作筛选器统一处理通用操作

前言&#xff1a;什么是操作筛选器 操作筛选器是 ASP.NET Core Web API 中的一种过滤器&#xff0c;用于在执行控制器操作&#xff08;Action&#xff09;之前或之后执行一些代码&#xff0c;完成特定的功能&#xff0c;比如执行日志记录、身份验证、授权、异常处理等通用的处…
阅读更多...
Java多线程--线程的生命周期

Java多线程--线程的生命周期

文章目录 一、JDK1.5之前&#xff1a;5种状态五种状态1、新建2、就绪3、运行4、阻塞5、死亡 二、JDK1.5及之后&#xff1a;六种状态 Java语言使用 Thread类及其子类的对象来表示 线程&#xff0c;在它的一个完整的生命周期中通常要经历如下一些状态。 一、JDK1.5之前&#xf…
阅读更多...
搜狐新闻客户端使用Kotlin之后对JSON解析框架的探索

搜狐新闻客户端使用Kotlin之后对JSON解析框架的探索

本文字数&#xff1a;7488字 预计阅读时间&#xff1a;45分钟 01 引言 自2017年Google发布Kotlin语言之后&#xff0c;Android开发由原来的Java开始向Kotlin过度&#xff0c;目前绝大部分Android开发岗位基本要求就是熟练使用Kotlin。事实上&#xff0c;很多有着多年历史的项目…
阅读更多...
CAD-autolisp（二）——选择集、命令行设置对话框、符号表

CAD-autolisp（二）——选择集、命令行设置对话框、符号表

目录 一、选择集1.1 选择集的创建1.2 选择集的编辑1.3 操作选择集 二、命令行设置对话框2.1 设置图层2.2 加载线型2.3 设置字体样式2.4 设置标注样式&#xff08;了解即可&#xff09; 三、符号表3.1 简介3.2 符号表查找3.2 符号表删改增 一、选择集 定义&#xff1a;批量选择…
阅读更多...
npm sill idealTree buildDeps 安装踩坑指南

npm sill idealTree buildDeps 安装踩坑指南

参考&#xff1a;https://www.yuucn.com/a/1565526.html https://blog.csdn.net/m0_65066691/article/details/128168066 https://blog.csdn.net/Johanna51/article/details/123360477 通过如下指令获得用户配置文件目录&#xff0c; 删除.npmrc文件 npm config get usercon…
阅读更多...
开发手札：Github Timeout 22

开发手札：Github Timeout 22

今天&#xff08;2024.01.26日&#xff09;&#xff0c;提交github又出现了ssh connect timeout errorcode 22&#xff0c;不论是创建新的sshkey还是配置.ssh/config都没用。 偶然在知乎上看到了解决方案&#xff0c;只需要在host中添加&#xff1a; 140.82.113.4 githu…
阅读更多...
【广度优先搜索】【拓扑排序】【C++算法】913. 猫和老鼠

【广度优先搜索】【拓扑排序】【C++算法】913. 猫和老鼠

作者推荐 【动态规划】【map】【C算法】1289. 下降路径最小和 II 本文涉及知识点 广度优先搜索 拓扑排序 逆推 LeetCode913. 猫和老鼠 两位玩家分别扮演猫和老鼠&#xff0c;在一张 无向 图上进行游戏&#xff0c;两人轮流行动。 图的形式是&#xff1a;graph[a] 是一个列…
阅读更多...
最新文章

Copyright @ 2022~2023