【高阶数据结构】跳表

news2024/11/25 16:54:16

文章目录

  • 一、什么是跳表
  • 二、跳表的效率如何保证？
  • 三、skiplist的实现
  • 四、skiplist跟平衡搜索树和哈希表的对比

一、什么是跳表

skiplist本质上也是一种查找结构，用于解决算法中的查找问题，跟平衡搜索树和哈希表的价值是
一样的，可以作为key或者key/value的查找模型。那么相比而言它的优势是什么的呢？这么等我
们学习完它的细节实现，我们再来对比。

skiplist 是由 William Pugh 发明的，最早出现于他在1990年发表的论文 《Skip Lists: AProbabilistic Alternative to Balanced Trees》

skiplist，顾名思义，首先它是一个list。实际上，它是在有序链表的基础上发展起来的。如果是一
个有序的链表，查找数据的时间复杂度是O(N)。

William Pugh开始的优化思路：

  1. 假如我们每相邻两个节点升高一层，增加一个指针，让指针指向下下个节点，如下图b所示。这样所有新增加的指针连成了一个新的链表，但它包含的节点个数只有原来的一半。由于新增加的指针，我们不再需要与链表中每个节点逐个进行比较了，需要比较的节点数大概只有原来的一半。
  2. 以此类推，我们可以在第二层新产生的链表上，继续为每相邻的两个节点升高一层，增加一个指针，从而产生第三层链表。如下图c，这样搜索效率就进一步提高了。
  3. skiplist正是受这种多层链表的想法的启发而设计出来的。实际上，按照上面生成链表的方式，上面每一层链表的节点个数，是下面一层的节点个数的一半，这样查找过程就非常类似二分查找，使得查找的时间复杂度可以降低到O(log n)。但是这个结构在插入删除数据的时候有很大的问题，插入或者删除一个节点之后，就会打乱上下相邻两层链表上节点个数严格的2:1的对应关系。如果要维持这种对应关系，就必须把新插入的节点后面的所有节点（也包括新插入的节点）重新进行调整，这会让时间复杂度重新蜕化成O(n)。
    在这里插入图片描述
    查找的过程：假如要查找的值是key，那么需要看下一个节点的值是否比key大，如果比key大， 就向下走。如果比key小，就向右走。如果没有找到，就会走到第-1层。
    skiplist的设计为了避免这种问题，做了一个大胆的处理，不再严格要求对应比例关系，而是插入一个节点的时候随机出一个层数。这样每次插入和删除都不需要考虑其他节点的层数，这样就好处理多了。细节过程入下图：
    在这里插入图片描述

二、跳表的效率如何保证？

上面我们说到，skiplist插入一个节点时随机出一个层数，听起来怎么这么随意，如何保证搜索时的效率呢？
这里首先要细节分析的是这个随机层数是怎么来的。一般跳表会设计一个最大层数maxLevel的限制，其次会设置一个多增加一层的概率p。那么计算这个随机层数的伪代码如下图：
在这里插入图片描述

在 Redis 的 skiplist 实现中，这两个参数的取值为：p = 1/4 和 maxLevel = 32。注：谷歌的开源项目 LevelDB（小型的 KV 型数据库）也采用了 skiplist，有兴趣的大佬可以了解一下！

根据前面randomLevel()的伪码，我们很容易看出，产生越高的节点层数，概率越低。定量的分析
如下：

  • 节点层数至少为1。而大于1的节点层数，满足一个概率分布。
  • 节点层数恰好等于1的概率为1-p。
  • 节点层数大于等于2的概率为p，而节点层数恰好等于2的概率为p(1-p)。
  • 节点层数大于等于3的概率为p2，而节点层数恰好等于3的概率为p2*(1-p)。
  • 节点层数大于等于4的概率为p3，而节点层数恰好等于4的概率为p3*(1-p)
  • …

因此，一个节点的平均层数（也包含的平均指针数目）计算如下：

在这里插入图片描述
现在很容易计算出：

  • 当p=1/2时，每个节点所包含的平均指针数目为2；
  • 当p=1/4时，每个节点所包含的平均指针数目为1.33。

在这里插入图片描述

跳表的平均时间复杂度为O(logN)，这个推导的过程比较复杂，这里我们稍微提一下。

三、skiplist的实现

在这里插入图片描述

结点的设计

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

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

因为每个结点的层数是随机的，所以申请一个新节点需要知道其层数和存储的值，通过vector的下标可以表示层数。

整体设计

class Skiplist {
	typedef SkiplistNode Node;
public:
	Skiplist() {
		srand(time(0));

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

private:
	Node* _head; // 哨兵位头节点
	size_t _maxLevel = 32; // 最高的层数
	double _p = 0.25; // 增加一层的概率
};

哨兵位头节点的层数是该跳表中最高的，初始时让哨兵位的层数为1.增加一层的概率是0.25，理论而言，概率越大，效率越高。

节点的随机层数

计算这个随机层数的伪代码如下图：

在这里插入图片描述

C语言产生随机数

int RandomLevel()
{
	size_t level = 1;
	// rand() ->[0, RAND_MAX]之间
	// rand() 《= RAND_MAX*_p 可以保证增加一层的概率是_p
	// level <= maxLevel 保证随机层数不超过最高层数maxLevel
	while (rand() <= RAND_MAX*_p && level < _maxLevel)
	{
		++level;
	}
	return level;
}

C++产生随机数

int RandomLevel()
{
	static std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
	static std::uniform_real_distribution<double> distribution(0.0, 1.0);

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

	return level;
}

这里我们需要注意的是：因为C语言产生的随机数范围是0到32767之间的数，范围比较小。不过可以通过加减一些数来扩大随机数的范围。

skiplist的查找

查找的过程:查找是要和下一个节点的值相比，并不是和当前节点的值相比一开始cur在哨兵位头节点的最高层 head，开始进行比较。假如要查找的值为target，如果下一个节点为空或者下一个节点的值比target大，那么cur需要向下一层走;如果下一个节点的值比target下，那么cur向右走。重复上述过程，直至找到或者没找到(没找到的话，cur会去到第-1层，注:层数是从第0层开始的)

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

skiplist的插入

无论是插入值还是删除值，都需要找到该值的前面的节点，这样才能修改指针的指向关系。我们可以将这个保存前一个指针的操作封装成一个函数，提供给插入和删除接口使用。

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

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

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

			// 向下走
			--level;
		}
	}

	return prevV;
}

在这里插入图片描述

void add(int num) {
	vector<Node*> prevV = FindPrevNode(num);
	
	int n = RandomLevel();
	Node* newnode = new Node(num, n);
	
	// 如果n超过当前最大的层数，那就升高一下_head的层数
	if (n > _head->_nextV.size())
	{
		_head->_nextV.resize(n, nullptr);
		prevV.resize(n, _head);
	}
	
	// 链接前后节点
	for (size_t i = 0; i < n; ++i)
	{
		newnode->_nextV[i] = prevV[i]->_nextV[i];
		prevV[i]->_nextV[i] = newnode;
	}
}

删除节点
在这里插入图片描述

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

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

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

		return true;
}

注意：如果删除的节点的层数是最高的，那么可以将哨兵位头结点的层数降一降。如何判断删除的节点层数是不是最高的呢？从哨兵位头结点的最高层其，如果该层的指针指向空，那么就说明删除的节点层数最高。当前层指针指向空，那么就需要看下一层指针是否指向空。以此类推，直至指针不在指向空，那么就可以求出删除最高节点后剩余节点的最高层数了。

在这里插入图片描述

打印跳表

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

		cur = cur->_nextV[0];
	}
}

打印跳表函数可以让我们更好的观察跳表的样子。

完整代码

#include <iostream>
#include <vector>
#include <time.h>
#include <random>
#include <chrono>
using namespace std;

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

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

class Skiplist {
	typedef SkiplistNode Node;
public:
	Skiplist() {
		srand(time(0));

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

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

		return false;
	}

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

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

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

				// 向下走
				--level;
			}
		}

		return prevV;
	}

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

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

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

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

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

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

			// 如果删除最高层节点，把头节点的层数也降一下
			int i = _head->_nextV.size() - 1;
			while (i >= 0)
			{
				if (_head->_nextV[i] == nullptr)
					--i;
				else
					break;
			}
			_head->_nextV.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 RandomLevel()
	{
		static std::default_random_engine generator(std::chrono::system_clock::now().time_since_epoch().count());
		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()
	{
		/*int level = _head->_nextV.size();
		for (int i = level - 1; i >= 0; --i)
		{
			Node* cur = _head;
			while (cur)
			{
				printf("%d->", cur->_val);
				cur = cur->_nextV[i];
			}
			printf("\n");
		}*/

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

			cur = cur->_nextV[0];
		}
	}
	
private:
	Node* _head;
	size_t _maxLevel = 32;
	double _p = 0.5;
};

四、skiplist跟平衡搜索树和哈希表的对比

  • skiplist 相比平衡搜索树(AVL 树和红黑树)对比，都可以做到遍历数据有序，时间复杂度也差不多。skiplist 的优势是：a、skiplist 实现简单，容易控制。平衡树增删查改遍历都更复杂。b、skiplist 的额外空间消耗更低。平衡树节点存储每个值有三叉链，平衡因子或者颜色等消耗。skiplist 中 p = 1 / 2 时，每个节点所包含的平均指针数目为 2；skiplist 中 p = 1 / 4 时，每个节点所包含的平均指针数目为 1.33；
  • skiplist 相比哈希表而言，就没有那么大的优势了。相比而言，a、哈希表平均时间复杂度是 O(1)，比 skiplist快。b、哈希表空间消耗略多一点。skiplist 优势如下：a、遍历数据有序。b、skiplist 空间消耗略小一点，哈希表存在链接指针和表空间消耗。c、哈希表扩容有性能损耗。d、哈希表在极端场景下哈希冲突高，效率下降厉害，需要红黑树补足接力。

在这里插入图片描述

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

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

相关文章

Windows环境Docker安装

Windows环境Docker安装

目录 安装Docker Desktop的步骤 Docker Desktop 更新WSL WSL 的手动安装步骤 Windows PowerShell 拉取&#xff08;Pull&#xff09;镜像 查看已下载的镜像 输出"Hello Docker!" Docker Desktop是Docker官方提供的用于Windows的图形化桌面应用程序&#xff0c…
阅读更多...
区间预测 | MATLAB实现QRBiLSTM双向长短期记忆神经网络分位数回归多输入单输出区间预测

区间预测 | MATLAB实现QRBiLSTM双向长短期记忆神经网络分位数回归多输入单输出区间预测

区间预测 | MATLAB实现QRBiLSTM双向长短期记忆神经网络分位数回归多输入单输出区间预测 目录 区间预测 | MATLAB实现QRBiLSTM双向长短期记忆神经网络分位数回归多输入单输出区间预测效果一览基本介绍模型描述程序设计参考资料 效果一览 基本介绍 区间预测 | MATLAB实现QRBiLSTM…
阅读更多...
odoo16 用好计量单位中的激活功能

odoo16 用好计量单位中的激活功能

odoo16 用好计量单位中的激活功能 根据国内常用&#xff0c;把不常用的单位去除&#xff0c;删除不了&#xff0c;提示已用&#xff0c;其实不用删除&#xff0c;每个单位后有个激活功能&#xff0c;选一下就可以了&#xff0c;显示成整洁的界面了 第一次用时&#xff0c;小伙伴…
阅读更多...
解决spring cloud 中使用spring security全局异常处理器失效

解决spring cloud 中使用spring security全局异常处理器失效

写auth认证模块实现忘记密码与注册功能时&#xff0c;用异常抛出&#xff0c;全局异常处理器无法捕获。 无法进行异常捕捉 解决方案&#xff1a;使用WebSecurityConfigurerAdapter.configure中http实现自定义异常&#xff1a; EnableWebSecurity EnableGlobalMethodSecurity(…
阅读更多...
87、springcloud核心组件及其作用

87、springcloud核心组件及其作用

spring Eureka: 服务注册与发现 注册:&#xff1a;每个服务都向Eureka登记自己提供服务的元数据&#xff0c;包括服务的ip地址、端口号、版本号、通信协议等 eureka将各个服务维护在了一个服务清单中 (双层Map&#xff0c;第一层key是服务名&#xff0c;第二层key是实例名&…
阅读更多...
macOS 源码编译 qpress

macOS 源码编译 qpress

╰─➤ git clone https://github.com/PierreLvx/qpress.git ╰─➤ cd qpress ╰─➤ make g -O3 -o qpress -x c quicklz.c -x c qpress.cpp aio.cpp utilities.cpp -lpthread -Wall -Wextra -Werror ╰─➤ sudo make install …
阅读更多...
Vue--》打造个性化医疗服务的医院预约系统（三）

Vue--》打造个性化医疗服务的医院预约系统（三）

今天开始使用 vue3 + ts 搭建一个医院预约系统的前台页面，因为文章会将项目的每一个地方代码的书写都会讲解到，所以本项目会分成好几篇文章进行讲解，我会在最后一篇文章中会将项目代码开源到我的GithHub上，大家可以自行去进行下载运行，希望本文章对有帮助的朋友们能多多关…
阅读更多...
Java基础小知识（待续）

Java基础小知识（待续）

类型转换、ASCII码、除法取余、三元表达式 long x 100;//int->long自动类型转换&#xff08;隐式) 1&#xff0e;特点:代码不需要进行特殊处理&#xff0c;自动完成。2&#xff0e;规则:数据范围从小到大。double y 2.5F;//2.5 float->double自动类型转换&#xff08…
阅读更多...
pyqt5-Ctrl+鼠标滚轮实现文本区文字大小调整

pyqt5-Ctrl+鼠标滚轮实现文本区文字大小调整

技术简介 在 PyQt5 中&#xff0c;你可以使用 QTextEdit 的 wheelEvent 方法和 QKeyEvent 的 key() 方法来检测 Ctrl 键和鼠标滚轮事件&#xff0c;从而实现按下 Ctrl 键并滚动鼠标滚轮时&#xff0c;调整 QTextEdit 的字体大小。 这个示例中&#xff0c;我们创建了一个窗口&am…
阅读更多...
模板方法模式（java）

模板方法模式（java）

目录 结构 案例 代码实现 抽象类 具体子类 测试类 优缺点 优点 缺点 结构 模板方法&#xff08;Template Method&#xff09;模式包含以下主要角色&#xff1a; 抽象类&#xff08;Abstract Class&#xff09;&#xff1a;负责给出一个算法的轮廓和骨架。它由一个模板…
阅读更多...
基于SPDK-vhost的云原生Kubevirt虚拟化存储IO的优化方案

基于SPDK-vhost的云原生Kubevirt虚拟化存储IO的优化方案

摘要 本文主要介绍针对云原生kubernetes虚拟化IO的应用场景&#xff0c;在Kubevirt中引入SPDK-vhost的支持&#xff0c;来加速虚机中IO存储性能。同时基于Intel开源的Workload Service Framework[1]平台集成部署一套端到端虚拟化IO的应用场景做基本的性能对比测试。 云原生Kube…
阅读更多...
Failed to load response data：No data found for resource with given identifier

Failed to load response data：No data found for resource with given identifier

前言 关于跨域的另一种解释 前端Ajax访问后端&#xff0c;表单提交&#xff0c;有一个接口报错&#xff0c;其他都没问题 网上看了很多案例方法&#xff0c;均不适用&#xff1b;早上改代码过程中&#xff0c;改好了&#xff0c;话不多说&#xff0c;上原因 原因 提前关闭页…
阅读更多...
CentOS7系统下Docker容器基于TensorFlow测试GPU

CentOS7系统下Docker容器基于TensorFlow测试GPU

前言 当基于nvidia gpu开发的docker镜像在实际部署时&#xff0c;需要先安装nvidia docker。安装nvidia docker前需要先安装原生docker compose 1. CentOS7安装docker详细教程 安装docker 1. Docker 要求 CentOS 系统的内核版本高于 3.10 &#xff0c;查看本页面的前提条件来验…
阅读更多...
辅助笔记-linux新增硬盘

辅助笔记-linux新增硬盘

linux新增硬盘 文章目录 linux新增硬盘步骤1&#xff1a;添加硬盘步骤2&#xff1a;对硬盘进行分区步骤3&#xff1a;对硬盘分区进行格式化步骤4&#xff1a;将硬盘分区挂载到目录上步骤5&#xff1a;设置“永久挂载” 本文主要参考B站视频“P59_韩顺平Linux_增加磁盘应用实例”…
阅读更多...
IDEA： 将第三方依赖打入jar包

IDEA： 将第三方依赖打入jar包

文章目录 一、添加自定义的jar包到lib目录下二、将自定义依赖包打入jar包方式1、使用springboot自带的插件 一、添加自定义的jar包到lib目录下 参考往期文章&#xff1a;IDEA中Java项目创建lib目录(添加依赖jar包代替maven依赖) 二、将自定义依赖包打入jar包 方式1、使用spr…
阅读更多...
centos7下载mysql5.7，jdk1.8

centos7下载mysql5.7，jdk1.8

前言&#xff1a;最近公司服务器从阿里云换到腾讯云了&#xff08;为了省钱啧啧&#xff09;&#xff0c;所以这个相关环境的配置工作&#xff0c;由我来负责了。 1.Mysql 1.下载 第一步&#xff1a; rpm -ivh https://dev.mysql.com/get/mysql57-community-release-el7-11…
阅读更多...
【算法基础：数学知识】4.4 快速幂

【算法基础：数学知识】4.4 快速幂

文章目录 快速幂例题列表875. 快速幂⭐⭐⭐⭐⭐&#xff08;重要&#xff01;&#xff09;代码写法1——递归代码写法2——迭代递归写法 与 迭代写法的 对比 876. 快速幂求逆元&#x1f6b9;&#xff08;需要理解逆元的概念&#xff09;TODO乘法逆元介绍解法代码 快速幂 https…
阅读更多...
python机器学习（三）特征预处理、鸢尾花案例--分类、线性回归、代价函数、梯度下降法、使用numpy、sklearn实现一元线性回归

python机器学习（三）特征预处理、鸢尾花案例--分类、线性回归、代价函数、梯度下降法、使用numpy、sklearn实现一元线性回归

K-近邻算法(K-Nearest Neighboor) 特征预处理 数据预处理的过程。数据存在不同的量纲、数据中存在离群值&#xff0c;需要稳定的转换数据&#xff0c;处理好的数据才能更好的去训练模型&#xff0c;减少误差的出现。 标准化 数据集的标准化对scikit-learn中实现的大多数机器…
阅读更多...
WPF实战项目十（API篇）：引入工作单元UnitOfWork

WPF实战项目十（API篇）：引入工作单元UnitOfWork

1、通过github地址&#xff1a;https://github.com/arch/UnitOfWork&#xff0c;下载UnitOfWork的代码&#xff0c;将工作单元部分的代码引用到自己的项目&#xff0c;新增UnitOfWork文件夹。 2、在UnitOfWork文件夹下引用UnitOfWork下的IPagedList.cs、PagedList.cs类&#xf…
阅读更多...
探索物联网HMI的端口转发和NAT功能

探索物联网HMI的端口转发和NAT功能

前言 端口转发和NAT功能常用于内网穿透&#xff0c;实现内部网络和外部网络之间的数据传输&#xff0c;工作人员通过外部网络便可安全访问到内网设备&#xff0c;实现设备的状态监测。接下来小编将为大家介绍支持端口转发和NAT功能的虹科物联网HMI是如何帮助用户实现内网穿透。…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023