c++:(map和set的底层简单版本,红黑树和AVL树的基础) 二叉搜索树(BST)底层和模拟实现

news2024/11/20 8:37:44

文章目录

  • 二叉搜索树的概念
  • 二叉搜索树的操作
    • 二叉搜索树的查找find
  • 二叉搜索树的模拟实现
    • 构造节点
    • insert
    • find
    • erase(细节巨多,面试可能会考)
      • a.叶子节点
      • b.有一个孩子
        • 左孩子
        • 右孩子
      • c.有两个孩子
        • 注意:
      • erase代码
    • 中序遍历
  • 二叉搜索树的应用
    • k模型
      • k模型模拟实现的总代码
    • k-value模型
      • k-value模型模拟实现的总代码
  • 二叉搜索树的不足
  • AVL树和红黑树的出现
  • 总结

二叉搜索树的概念

二叉搜索树,它的左子树的值比根的值小,右子树的值比根的值大
在这里插入图片描述
比如这一树,根节点的值8比左子树所有节点都大,比右子树的所有节点都小.

二叉搜索树的操作

二叉搜索树的查找find

因为二叉树有以上特性,所有使得它在搜索方面有极大的优势.
比如我们要找值为7的节点在不在
1.我们从根节点开始找,因为7<根节点的值8,所有根节点在左子树
在这里插入图片描述
2.现在根节点的值为3<7,所有在3的右子树中
在这里插入图片描述
3.现在根节点的值为6<7,所有在6的右子树中,刚好右子树的节点为7.
在这里插入图片描述
二叉搜索树最多寻找高度次,如果走到空还没有找到,说明这个值不存在

二叉搜索树的模拟实现

构造节点

	template<class K>
	struct BSTreeNode
	{
		typedef BSTreeNode<K> Node;
		Node* _left;
		Node* _right;
		K _val;

		BSTreeNode(const K& val)
			:_left(nullptr)
			, _right(nullptr)
			, _val(val)
		{}
	};

_val里面存节点的值

insert

bool insert(const K& val)
{
	//a.树为空,直接构造新节点赋值给根节点
	if (_root == nullptr)
	{
		_root = new Node(val);
		return true;
	}
	Node* parent = nullptr;
	Node* cur = _root;
	//找到空的节点进行插入
	while (cur)
	{
		if (cur->_val < val)
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (cur->_val > val)
		{
			parent = cur;
			cur = cur->_left;
		}
		// 二叉搜索树默认不允许重复
		else
		{
			return false;
		}
	}
	cur = new Node(val);
	if (parent->_val < val)
	{
		parent->_right = cur;
	}
	else
	{
		parent->_left = cur;
	}
	return true;
}

插入有两种情况
a.树为空,直接构造新节点赋值给根节点
b.树不为空,按照二叉树的性质找到应该插入的空位置插入.
注意:
在b情况下,要找到新节点的位置,也要找到该节点的父亲节点,这样才能进行链接
假设要插入0节点,不光要找到0节点应该放的位置,还要找到0节点的父亲1,将他们链接起来
在这里插入图片描述

find

bool find(const K& val)
{
	Node* cur = _root;
	while (cur)
	{
		if (cur->_val < val)
		{
			cur = cur->_right;
		}
		else if (cur->_val > val)
		{
			cur = cur->_left;
		}
		else
		{
			return true;
		}
	}
	return false;
}

按照二叉搜索树的概念,比根大的往右走,比根小的往左走.
找到返回true,找不到返回false

erase(细节巨多,面试可能会考)

erase里面的细节很多,要细品.

删除的节点有多种可能

a.叶子节点

在这里插入图片描述

比如这棵树我们要删除4节点,就只需要找到4节点和它的父亲节点6,让父亲节点6指向空,再删除4节点.

b.有一个孩子

特殊情况
要删除的是根节点,此时要更新新的根节点10.
在这里插入图片描述

if (_root == cur)
{
	_root = cur->_right;
	delete cur;
}
左孩子

右为空,父亲指向我的左
有一个左孩子,说明右子树为空.
此时要让父亲指向3的左边,此时不清楚是父亲的左边还是父亲的右边指向1节点

父亲的左指向我的左

父亲的右指向我的左
在这里插入图片描述
代码实现

if (cur->_right == nullptr)
{
	//删除头节点
	if (_root == cur)
	{
		_root = cur->_left;
		delete cur;
	}
	else
	{
		if (parent->_right == cur)
			parent->_right = cur->_left;
		else
			parent->_left = cur->_left;
		delete cur;

	}
}
右孩子

左为空, 父亲指向我的右

//左为空, 父亲指向我的右
else if (cur->_left == nullptr)
{
	//删除头节点
	if (_root == cur)
	{
		_root = cur->_right;
		delete cur;
	}
	else
	{
		if (parent->_right == cur)
			parent->_right = cur->_right;
		else
			parent->_left = cur->_right;
		delete cur;
	}
}

右孩子的判断和左孩子类似,方向反过来而已.

c.有两个孩子

在这里插入图片描述
找到左边的最大值或者右边的最小值,与目标值进行替换.
这里以右边的最小值为例.
我们寻找右边的最小值时,同时要找它的父亲节点,因为要对它的父亲节点进行修改.
找到右边的最小值为4,将4覆盖到cur上面,再删除right_min这个节点.
在这里插入图片描述

注意:

因为是寻找右子树的最小值,所以这个最小值理论上应该没有左子树.
如果有左子树,说明有更小的值.但是可能会有右子树.
所有要让right_min_parent左节点指向right_min的右节点.
这只是理论上,实际里面还有一个大坑
在这里插入图片描述
如果我们要删除的节点:cur和right_min_parent 指向同一个地方时,此时应该让right_min_parent 的右节点指向right_min的右节点.

//有两个孩子:找到左边的最大值或者右边的最小值,与目标值进行替换
					//让这个右最小节点的父亲的左边指向右最小的右边,因为它此时最多只有右孩子
else
{
	Node* right_min_parent = cur;
	Node* right_min = cur->_right;
	while (right_min->_left)
	{
		right_min_parent = right_min;
		right_min = right_min->_left;
	}
	cur->_val = right_min->_val;
	//右最小节点,有坑,是连续存放的有序值
	if (cur->_right == right_min)
		right_min_parent->_right = right_min->_right;
	else
		right_min_parent->_left = right_min->_right;
	delete right_min;
}

erase代码

bool erase(const K& val)
		{
			Node* parent = _root;
			Node* cur = _root;
			//找到要删除的目标值
			while (cur)
			{
				if (cur->_val < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_val > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//只有一个孩子/叶子节点:让父亲节点指向子节点的右(nullptr)
					//右为空,父亲指向我的左
					if (cur->_right == nullptr)
					{
						//删除头节点
						if (_root == cur)
						{
							_root = cur->_left;
							delete cur;
						}
						else
						{
							if (parent->_right == cur)
								parent->_right = cur->_left;
							else
								parent->_left = cur->_left;
							delete cur;

						}
					}
					//左为空, 父亲指向我的右
					else if (cur->_left == nullptr)
					{
						//删除头节点
						if (_root == cur)
						{
							_root = cur->_right;
							delete cur;
						}
						else
						{
							if (parent->_right == cur)
								parent->_right = cur->_right;
							else
								parent->_left = cur->_right;
							delete cur;
						}
					}
					//有两个孩子:找到左边的最大值或者右边的最小值,与目标值进行替换
					//让这个右最小节点的父亲的左边指向右最小的右边,因为它此时最多只有右孩子
					else
					{
						Node* right_min_parent = cur;
						Node* right_min = cur->_right;
						while (right_min->_left)
						{
							right_min_parent = right_min;
							right_min = right_min->_left;
						}
						cur->_val = right_min->_val;
						//右最小节点,有坑,是连续存放的有序值
						if (cur->_right == right_min)
							right_min_parent->_right = right_min->_right;
						else
							right_min_parent->_left = right_min->_right;
						delete right_min;
					}
					return true;
				}
			}
			return false;
		}

中序遍历

		void MidOrder()
		{
			_MidOrder(_root);
			cout << endl;
		}
	private:
		void _MidOrder(const Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_MidOrder(root->_left);
			std::cout << root->_val << " ";
			_MidOrder(root->_right);
		}

首先,中序的搜索方式是左子树 根 右子树.按照这个顺序就能有序的取出搜索二叉树里面的值了

为什么会有两个函数?
因为函数的形参没有this指针,没法调用_root根节点,我们需要另外一个函数来传_root根节点

二叉搜索树的应用

k模型

k模型跟我们上面实现的一样,只存储一个值
比如:我们可以用这个功能查找到我们英文作文里面的拼写错误的单词.
我们可以把词库里面所有的英语单词丢进这个二叉搜索树,再遍历整个作文,检查每个单词是否存在,不存在就报错.

k模型模拟实现的总代码

namespace shh1
{
	template<class K>
	struct BSTreeNode
	{
		typedef BSTreeNode<K> Node;
		Node* _left;
		Node* _right;
		K _val;

		BSTreeNode(const K& val)
			:_left(nullptr)
			, _right(nullptr)
			, _val(val)
		{}
	};

	//k模型
	template<class K>
	class BSTree
	{
		typedef BSTreeNode<K> Node;
	public:
		bool insert(const K& val)
		{
			if (_root == nullptr)
			{
				_root = new Node(val);
				return true;
			}
			Node* parent = nullptr;
			Node* cur = _root;
			//找到空的节点进行插入
			while (cur)
			{
				if (cur->_val < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_val > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				// 二叉搜索树默认不允许重复
				else
				{
					return false;
				}
			}
			cur = new Node(val);
			if (parent->_val < val)
			{
				parent->_right = cur;
			}
			else
			{
				parent->_left = cur;
			}
			return true;
		}

		bool erase(const K& val)
		{
			Node* parent = _root;
			Node* cur = _root;
			//找到要删除的目标值
			while (cur)
			{
				if (cur->_val < val)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_val > val)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//只有一个孩子/叶子节点:让父亲节点指向子节点的右(nullptr)
					//右为空,父亲指向我的左
					if (cur->_right == nullptr)
					{
						//删除头节点
						if (_root == cur)
						{
							_root = cur->_left;
							delete cur;
						}
						else
						{
							if (parent->_right == cur)
								parent->_right = cur->_left;
							else
								parent->_left = cur->_left;
							delete cur;

						}
					}
					//左为空, 父亲指向我的右
					else if (cur->_left == nullptr)
					{
						//删除头节点
						if (_root == cur)
						{
							_root = cur->_right;
							delete cur;
						}
						else
						{
							if (parent->_right == cur)
								parent->_right = cur->_right;
							else
								parent->_left = cur->_right;
							delete cur;
						}
					}
					//有两个孩子:找到左边的最大值或者右边的最小值,与目标值进行替换
					//让这个右最小节点的父亲的左边指向右最小的右边,因为它此时最多只有右孩子
					else
					{
						Node* right_min_parent = cur;
						Node* right_min = cur->_right;
						while (right_min->_left)
						{
							right_min_parent = right_min;
							right_min = right_min->_left;
						}
						cur->_val = right_min->_val;
						//右最小节点,有坑,是连续存放的有序值
						if (cur->_right == right_min)
							right_min_parent->_right = right_min->_right;
						else
							right_min_parent->_left = right_min->_right;
						delete right_min;
					}
					return true;
				}
			}
			return false;
		}

		bool find(const K& val)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_val < val)
				{
					cur = cur->_right;
				}
				else if (cur->_val > val)
				{
					cur = cur->_left;
				}
				else
				{
					return true;
				}
			}
			return false;
		}

		void MidOrder()
		{
			_MidOrder(_root);
			cout << endl;
		}
	private:
		void _MidOrder(const Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_MidOrder(root->_left);
			std::cout << root->_val << " ";
			_MidOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};
	void BST_Test1()
	{
		int a[] = { 6,5,1,4,7,2,3,8,9,11,55,68,-1 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.insert(e);
		}
		t.MidOrder();
	}

	void BST_Test2()
	{
		int a[] = { 8 };
		BSTree<int> t;
		for (auto e : a)
		{
			t.insert(e);
		}
		t.MidOrder();

		for (auto e : a)
		{
			t.erase(e);
			t.MidOrder();
		}
	}
}

k-value模型

每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。
这个在我们日常生活很常见,比如词典的翻译,我们在key里面存英语单词,value里面存相对应的中文翻译.
我们就可以通过输入英文单词得到其对应的中文翻译.
下面稍作演示:

void TestBSTree()
	{
		BSTree<string, string> dict;
		dict.Insert("insert", "插入");
		dict.Insert("erase", "删除");
		dict.Insert("left", "左边");
		dict.Insert("string", "字符串");

		string str;
		while (cin >> str)
		{
			auto ret = dict.Find(str);
			if (ret)
			{
				cout << str << ":" << ret->_val << endl;
			}
			else
			{
				cout << "单词拼写错误" << endl;
			}
		}
	}

在这里插入图片描述

k-value模型模拟实现的总代码

k-value模型的代码和上面的key模型类似,我们只需要要添加新节点的时候再加一个值就行.

namespace shh2
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;
		Node* _left;
		Node* _right;
		K _key;
		V _val;

		BSTreeNode(const K& key, const V& val)
			:_left(nullptr)
			, _right(nullptr)
			, _key(key)
			, _val(val)
		{}
	};

	template<class K, class V>
	class BSTree
	{
		typedef BSTreeNode<K, V> Node;
		Node* _root = nullptr;
	public:
		bool Insert(const K& key, const V& val)
		{
			//头节点
			if (_root == nullptr)
			{
				_root = new Node(key, val);
				return true;
			}

			Node* parent = _root;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//已经插入过的
					return false;
				}
			}
			cur = new Node(key, val);
			if (parent->_key < key)
				parent->_right = cur;
			else
				parent->_left = cur;
			return true;
		}

		Node* Find(const K& key)
		{
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					cur = cur->_left;
				}
				else
				{
					return cur;
				}
			}
			return nullptr;
		}
		bool Erase(const K& key)
		{
			Node* parent = _root;
			Node* cur = _root;
			while (cur)
			{
				if (cur->_key < key)
				{
					parent = cur;
					cur = cur->_right;
				}
				else if (cur->_key > key)
				{
					parent = cur;
					cur = cur->_left;
				}
				else
				{
					//叶子节点和只有一个孩子的一起处理
					//左为空,父亲的左/右指向我的右
				   	if (cur->_left == nullptr)
				   	{
				   		// 如果为根节点
				   		if (cur == _root)
				   		{
				   			_root = cur->_right;
				   			delete cur;
				   		}
				   		else
				   		{
				   			if (cur == parent->_left)
				   			{
				   				parent->_left = cur->_right;
				   			}
				   			else
				   			{
				   				parent->_right = cur->_right;
				   			}
				   			delete cur;
				   		}
				   	}
					//右为空,父亲的左/右指向我的左
					else if (cur->_right == nullptr)
					{
						// 如果为根节点
						if (cur == _root)
						{
								_root = cur->_left;
								delete cur;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_left;
							}
							else
							{
								parent->_right = cur->_left;
							}
							delete cur;
						}
					}
					//两个孩子 找到cur左子树的最大值替换
					else
					{
						Node* left_max_parent = cur;
						Node* left_max = cur->_left;
						while (left_max->_right)
						{
							left_max_parent = left_max;
							left_max = left_max->_right;
						}
						swap(cur->_key, left_max->_key);
						if (left_max_parent->_left = left_max)
							left_max_parent->_left = left_max->_left;
						else
							left_max_parent->_right = left_max->_left;
						delete left_max;
					}
				   	return true;
				}
		 
			}
		}
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}
			_InOrder(root->_left);
			cout << root->_key << ":" << root->_val << endl;
			_InOrder(root->_right);
		}
		void InOrder()
		{
			_InOrder(_root);
		}
	};

	void TestBSTree()
	{
		BSTree<string, string> dict;
		dict.Insert("insert", "插入");
		dict.Insert("erase", "删除");
		dict.Insert("left", "左边");
		dict.Insert("string", "字符串");

		string str;
		while (cin >> str)
		{
			auto ret = dict.Find(str);
			if (ret)
			{
				cout << str << ":" << ret->_val << endl;
			}
			else
			{
				cout << "单词拼写错误" << endl;
			}
		}
	}
};

二叉搜索树的不足

当二叉搜索树有序存入了一段值
在这里插入图片描述
这棵树会退化成单叉树,因为插入,查找和删除的时间复杂度都是高度次,
所以在这种情况下插入,查找和删除的时间复杂度会接近于N.搜索二叉树也就失去了它的优势.

AVL树和红黑树的出现

怎么解决这个问题呢,就要用到AVL和红黑树了.
在插入的时候,AVL树会查看树的高度是否平衡,
左子树和右子树的高度差不超过1.超过1会让树的几个节点之间发生旋转,最终这棵树会变成这样.
在这里插入图片描述
我们平时调用的容器map和set底层就是用AVL树和红黑树生成的.

总结

二叉搜索树的插入和查找不难,但是它的删除细节很多,分类很细,一不留神容易掉坑里面,面试也经常会考.大家如果不懂的话,要多看几遍.

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

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

相关文章

fb设备驱动框架分析

fb设备驱动框架分析

一、字符设备注册过程&#xff1a; 归根到底&#xff0c;fb设备也是一个字符设备&#xff0c;所以逃不开常规的字符设备驱动框架&#xff1a; Linux内核中编写字符设备驱动通常遵循以下步骤&#xff1a; ①、定义主设备号&#xff1a; 在Linux中&#xff0c;每个字符设备都…
阅读更多...
第十五届蓝桥杯python B组省赛

第十五届蓝桥杯python B组省赛

前言&#xff1a; 这是我第一次参加蓝桥杯&#xff0c;成绩并不理想&#xff0c;我反思了一下午&#xff0c;我的问题主要是知识点学不透&#xff0c;题目做的太少&#xff0c;而且学习的时候少数时间不专心&#xff0c;但是&#xff0c;我能感觉到我的学习能力并不弱&#xf…
阅读更多...
Unity TileMap入门

Unity TileMap入门

概述 相信很多同学学习制作游戏都是从2D游戏开始制作的吧&#xff0c;瓦片地图相信大家都有接触&#xff0c;那接下来让我们学习一下这部分的内容吧&#xff01; Tilemap AnimationFrameRate:设置每帧动画的播放速率。Color:瓦片地图的颜色TileAnchor:锚点&#xff0c;&#x…
阅读更多...
AI英语口语训练软件有哪些？这4款简单易用

AI英语口语训练软件有哪些？这4款简单易用

AI英语口语训练软件有哪些&#xff1f;AI英语口语训练软件在现代语言学习中确实扮演着举足轻重的角色。它们凭借先进的智能算法&#xff0c;能够为我们量身定制学习方案&#xff0c;精准识别并纠正发音错误&#xff0c;模拟真实对话场景&#xff0c;使学习过程更加高效、有趣。…
阅读更多...
Qt复习第二天

Qt复习第二天

1、菜单栏工具栏状态栏 #include "mainwindow.h" #include "ui_mainwindow.h" #pragma execution_character_set("utf-8"); MainWindow::MainWindow(QWidget *parent): QMainWindow(parent), ui(new Ui::MainWindow) {ui->setupUi(this);//菜…
阅读更多...
【C++】转换构造函数和类型转换函数

【C++】转换构造函数和类型转换函数

目录 转换构造函数转换构造函数调用 类型转换函数类型转换函数定义形式应用 转换构造函数 转换构造函数就是一种构造函数&#xff0c;将一个其他类型的数据转换成一个类的对象的构造函数。 类型->类对象 转换构造函数调用 &#xff08;1&#xff09;显式强制类型转换&…
阅读更多...
抽象类基本概念

抽象类基本概念

抽象类及抽象方法 概念&#xff1a;一个类中没有包含足够的信息来描绘一个具体的对象&#xff0c;这种类被定义为抽象类&#xff0c;含有抽象方法的类也被称为抽象类。 用通俗的话来说就是当一个类的某个功能&#xff08;方法&#xff09;实现不确定时&#xff0c;我们就将该…
阅读更多...
数据挖掘（二）数据预处理

数据挖掘（二）数据预处理

前言 基于国防科技大学 丁兆云老师的《数据挖掘》 数据挖掘 数据挖掘&#xff08;一&#xff09;数据类型与统计 2、数据预处理 2.1数据清理 缺失值处理&#xff1a; from sklearn.impute import SimpleImputer# 创建一个SimpleImputer对象&#xff0c;指定缺失值的处理策略…
阅读更多...
信息系统项目管理基础

信息系统项目管理基础

目录 一、项目管理概论 1、定义 2、项目管理的十二原则 3、SMART原则 4、项目经理 5、项目的生命周期 二、项目立项管理 1、项目启动过程 三、项目整合管理 1、管理基础 2、项目整合管理过程 ①制定项目章程 ②制定项目管理计划 ③指导与管理项目工作 ④管理项目…
阅读更多...
【算法与数据结构】数组

【算法与数据结构】数组

文章目录 前言数组数组的定义数组的基本操作增加元素删除元素修改元素查找元素 C STL 中的数组arrayvector Python3 中的列表访问更改元素值遍历列表检查列表中是否存在某元素增加元素删除元素拷贝列表总结 Python3 列表的常用操作 参考资料写在最后 前言 本系列专注更新基本数…
阅读更多...
计算机系列之数据库技术

计算机系列之数据库技术

13、数据库技术&#xff08;重点、考点&#xff09; 1、三级模式-两级映像&#xff08;考点&#xff09; 内模式&#xff1a;管理如何存储物理的数据&#xff0c;对应具体物理存储文件。 **模式&#xff1a;**又称为概念模式&#xff0c;就是我们通常使用的基本表&#xff0c…
阅读更多...
AI算法-高数3-导数-求导法则

AI算法-高数3-导数-求导法则

P16 2.2 求导法则&#xff0c;宋浩老师&#xff1a;2.2 求导法则_哔哩哔哩_bilibili 反函数求导法则&#xff1a; 复合函数求导&#xff1a;剥洋葱法。
阅读更多...
H5 鼠标点击粒子扩散效果

H5 鼠标点击粒子扩散效果

&#x1f9d0;别人的博客中有这样的效果&#xff0c;于是自己就尝试实现了一下。 效果如图 源码如下 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content&quo…
阅读更多...
一文彻底读懂信息安全等级保护：包含等保标准、等保概念、等保对象、等保流程及等保方案（附：等保相关标准文档）

一文彻底读懂信息安全等级保护：包含等保标准、等保概念、等保对象、等保流程及等保方案（附：等保相关标准文档）

1. 什么是等级保护&#xff1f; 1.1. 概念 信息安全等级保护是指根据我国《信息安全等级保护管理办法》的规定&#xff0c;对各类信息系统按照其重要程度和保密需求进行分级&#xff0c;并制定相应的技术和管理措施&#xff0c;确保信息系统的安全性、完整性、可用性。根据等…
阅读更多...
CTFHUB-技能树-Web题-RCE（远程代码执行）-文件包含

CTFHUB-技能树-Web题-RCE（远程代码执行）-文件包含

CTFHUB-技能树-Web题-RCE&#xff08;远程代码执行&#xff09; 文件包含 文章目录 CTFHUB-技能树-Web题-RCE&#xff08;远程代码执行&#xff09;文件包含解题方法1:![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/71f7355b3c124dfe8cdf1c95e6991553.png#pic_ce…
阅读更多...
Docker快速搭建NAS服务——NextCloud

Docker快速搭建NAS服务——NextCloud

Docker快速搭建NAS服务——NextCloud 文章目录 前言NextCloud的搭建docker-compose文件编写运行及访问 总结 前言 本文主要讲解如何使用docker在本地快速搭建NAS服务&#xff0c;这里主要写如下两种&#xff1a; FileBrowser1&#xff1a;是一个开源的Web文件管理器&#xff…
阅读更多...
我觉得POC应该贴近实际

我觉得POC应该贴近实际

今天我看到一位老师给我一份测试数据。 这是三个国产数据库。算是分布式的。其中有两个和我比较熟悉&#xff0c;但是这个数据看上去并不好。看上去第一个黄色的数据库数据是这里最好的了。但是即使如此&#xff0c;我相信大部分做数据库的人都知道。MySQL和PostgreSQL平时拿出…
阅读更多...
常用七大加密软件排行榜|好用加密文件软件分享

常用七大加密软件排行榜|好用加密文件软件分享

数据安全与隐私保护已成为我们每个人都必须面对的重要问题。 文件加密软件作为保障数据安全的关键工具&#xff0c;其重要性不言而喻。 在众多的加密软件中&#xff0c;哪些软件能够在保障数据安全的同时&#xff0c;又具备良好的易用性和稳定性呢&#xff1f; 本文将为您揭秘…
阅读更多...
YOLO系列笔记（十）—— 基础：卷积层及其计算公式

YOLO系列笔记（十）—— 基础：卷积层及其计算公式

卷积层及其计算公式 前言定义与功能计算过程与输出尺寸没有填充的情况有填充的情况 网络结构中的表示分析一&#xff1a;数字的含义分析二&#xff1a;分支的含义 前言 卷积层是在深度学习领域中非常常见、基础且重要的一种神经网络层。许多初学者可能会对卷积层的功能、其计算…
阅读更多...
【Git】Github创建远程仓库并与本地互联

【Git】Github创建远程仓库并与本地互联

创建仓库 点击生成新的仓库 创建成功后会生成一个这样的文件 拉取到本地 首先先确保本地安装了git 可以通过终端使用 git --version来查看是否安装好了git 如果显示了版本信息&#xff0c;说明已经安装好了git&#xff0c;这时候我们就可以进入我们想要clone到问目标文件夹 …
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023