【C++】---二叉搜索树

news2024/9/19 11:17:54

【C++】---二叉搜索树

  • 一、二叉搜索树概念
  • 二、二叉搜索树操作（非递归）
    • 1.二叉搜索树的查找 （非递归）
      • （1）查找
      • （2）中序遍历
    • 2.二叉搜索树的插入（非递归）
    • 3.二叉搜索树的删除（非递归）
  • 三、二叉搜索树操作（递归）
    • 1.二叉搜索树的查找（递归）
    • 2.二叉搜索树的插入（递归）
    • 3.二叉搜索树的删除（递归）
  • 四、二叉搜索树的默认成员函数
    • 1.构造
    • 2.拷贝构造
    • 3.赋值运算符重载
    • 4.析构
  • 五、K模型和KV模型搜索树
    • 1.K模型搜索树
    • 2.KV模型搜索树
  • 六、二叉搜索树性能分析

在这里插入图片描述

一、二叉搜索树概念

二叉搜索树又叫二叉排序数，它或者是空树，或者是具有以下性质的二叉树：

  1. 如果它的左子树不为空，那么左子树上所有节点的值都小于根结点的值。
  2. 如果它的右子树不为空，那么右子树上所有节点的值都大于根节点的值。
  3. 它的左右子树也是二叉搜索树。

在这里插入图片描述

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};

比如说：这个数组都可以将它化为二叉搜索树

在这里插入图片描述

总结：在左子树值比根小，右子树值比根大。 当树走中序遍历时，序列都是有序的。

二叉搜索树 的 结构定义：


#include<iostream>
using namespace std;

template<class K>
struct BSTreeNode
{
	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;
	
	K _key;

	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{

	}
};


template<class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
private:
	Node* _root;
public:

	BSTree()
		:_root(nullptr)
	{

	}
};

二、二叉搜索树操作（非递归）

1.二叉搜索树的查找 （非递归）

利用二分查找的方法，借助我们去二叉搜索树中查找节点。

在这里插入图片描述
在这里插入图片描述
查找的时间复杂度：最坏的情况，就是查找高度（h=logN）次，就可以判断一个值在不在节点里面。

（1）查找

查找的思路：

  1. key比当前结点的值小，往左走！
  2. key比当前结点的值大，往右走！
  3. key==当前结点的值，就找到了！

在这里插入图片描述

// 查找：
	Node* Find(const K& key)
	{
		Node* cur = _root;
		while (cur)
		{
			if (key < cur->_key)
			{
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				cur = cur->_right;
			}
			else
			{
				return cur;// 找到了！
			}
		}
		return nullptr;// 遍历完了，都还没找到！
	}

（2）中序遍历

由于根节点_root是私有成员变量，如果在main函数里面来进行中序遍历的话，这就是在类外对私有成员进行访问，这是不合法的！

所以说我们要解决这个问题，可以用这样：
在类的public内的 中序遍历 InOrder 里面 再套一层私有的中序遍历：_InOrder，这样，_InOrder身为私有函数，就可以访问：私有变量_root！

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
		{
			return;
		}
		_InOrder(root->_left);
		cout << root->_key << endl;
		_InOrder(root->_right);
	}
public:
	
	// 中序遍历：
	void InOrder() //这个函数 类外可以直接访问！
	{
		_InOrder(_root); // 这个函数，是 私有函数 对 私有成员 的访问！
		cout << endl;
	}

2.二叉搜索树的插入（非递归）

插入节点分两步：

（1）找位置

    ①key比当前节点值大，向左走

    ②key比当前节点值小，向右走

    ③key等于当前节点值，该节点值已经存在，插入失败

（2）插入

    ①key比父亲节点值小就插入父亲左子树

    ②key比父亲节点值大就插入父亲右子树

由于插入后，要将节点链接到树中，因此要定义parent节点，用来链接新节点：

在这里插入图片描述

// 插入：
	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}

		Node* cur = _root;
		Node* parent = nullptr;
		// (1) 找到插入的位置
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				return false;// 二叉搜索树不允许数据冗余！
			}
		}

		cur = new Node(key);

		// (2) 判断
		if (key<parent->_key)
		{
			parent->_left = cur;
		}
		else
		{
			parent->_right = cur;
		}
		return true;
	}

3.二叉搜索树的删除（非递归）

非递归删除：

（1）找位置

    ①key比当前节点值大，向左走

    ②key比当前节点值小，向右走

    ③key等于当前节点值，找到了，准备删除

（2）删除，有两种删除方法：非递归和递归

    非递归删除: 

    ①该节点没有孩子，即该节点是叶子节点，删除节点后把父亲指向自己的指针置空

在这里插入图片描述

    ②该节点有一个孩子，就把该节点的孩子节点的链接给该节点的父亲，顶替自己的位置，
    ①可以当成②的特殊情况

在这里插入图片描述

    ③该节点有两个孩子，找比它自己的左孩子大，比它自己的右孩子小的节点替换它
    （也就是拿它的左子树的最大节点或右子树的最小节点替换它），
    替换之后，该节点就只有一个孩子或没有孩子了，就变成①或②了。

在这里插入图片描述

// 删除
	bool erase(const K& key)
	{
		Node* cur = _root;
		Node* parent = nullptr;
		// (1) 找到插入的位置
		while (cur)
		{
			if (key < cur->_key)
			{
				parent = cur;
				cur = cur->_left;
			}
			else if (key > cur->_key)
			{
				parent = cur;
				cur = cur->_right;
			}
			else
			{
				break;
			}
		}
		// 1、2、 (子 代替 父亲的位置)

		// 大前提：如果要删除的节点，left为空
		if (cur->_left == nullptr)
		{
			// 如果要删除根！
			if (cur == _root)
			{
				_root = cur->_right;// 那就让cur的右当根
			}
			// 如果要删除的不是根！
			else
			{
				// 如果要删除的节点cur，在父亲的左边。

				// 因为是替代法，所以说要让 子 的位置代替 父亲 的位置，但是 子 的位置只有_right存在，所以说会把_right的位置放到即将要删除cur的位置。
				if (parent->_left == cur)
				{
					parent->_left = cur->_right;
				}
				else
				{
					parent->_right = cur->_right;
				}
			}

			delete cur;
		}


		// 大前提：如果要删除的节点，right为空
		else if (cur->_right == nullptr)
		{
			if (cur == _root)
			{
				_root = cur->_left;
			}

			else
			{
				// 因为是替代法，所以说要让 子 的位置代替 父亲 的位置，但是 子 的位置只有_left存在，所以说会把_left的位置放到即将要删除cur的位置。
				if (parent->_left == cur)
				{
					parent->_left = cur->_left;
				}
				else
				{
					parent->_right = cur->_left;
				}
			}
			delete cur;
		}

		// 3、要删除的cur不只有一个节点。可能有多个节点，甚至整个指子树
		// 找到要删除节点cur，左子树最大的节点，右子树最小的节点，来代替cur的位置。
		else
		{
			// 要么找cur左子树中的max，要么就找右子树中的min

			// 这里 以 RightMin为例！

			// (1)找到 RightMin (就像找 cur那样)
			Node* RightMin = cur->_right;
			Node* RightMinParent = cur; // 定义 RightMinParent 为了方便后续节点的连接。

			while (RightMin->_left)
			{
				RightMinParent = RightMin;
				RightMin = RightMin->_left;
			}
			// (2)找到了 就交换！
			swap(RightMin->_key, cur->_key);

			// (3) 交换完后 就链接！

			if (RightMinParent->_left == RightMin)
				RightMinParent->_left = cur;
			else
				RightMinParent->_right = cur;
			// 链接完成！

			delete cur;
		}

		return true;
	}

递归删除：

相对于非递归，只需要修改找到了要修改的代码：找到了后不需要管cur到底左为空、右为空、还是左右都不为空

① 找要删除节点的右子树的最小节点并把它的值保存起来

② 删除右子树的最小节点

③ 把要删除的节点值替换成右子树的最小节点值

在这里插入图片描述

                else//左右都不为空，替换法删除
                {
					//找右子树最小节点
					Node* minRight = cur->_right;
					while (minRight->_left)
					{
						minRight = minRight->_left;
					}
 
					//用min保存右子树最小节点的值
					K min = minRight->_key;
 
					//递归调用自己去替换删除节点，一定会走到左为空的情况处理
					this->Erase(min);
 
					//删除完毕替换节点之后，把cur的值替换成min
					cur->_key = min;
				}

三、二叉搜索树操作（递归）

理解了非递归操作以后， 递归操作就很简单了：

#include<iostream>
using namespace std;
 
//树的节点可以支持多种类型
template<class K>
//树节点结构
struct BSTreeNode
{
	BSTreeNode<K>* _left;//左指针
	BSTreeNode<K>* _right;//右指针
	K _key;//值
 
	//构造函数
	BSTreeNode(const K& key)
		:_left(nullptr)
		, _right(nullptr)
		, _key(key)
	{}
};
 
template<class K>
class BStree//树结构
{
	typedef BSTreeNode<K> Node;
public:
	//递归查找
	Node* FindR(const K& key)
	{
		return _FindR(_root, key);
	}
 
	//递归插入
	bool InsertR(const K& key)
	{
		return _InsertR(_root, key);
	}
 
	//递归删除
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	Node* _root;
};

由于_root是私有的，可以把递归子函数查找、插入、删除都定义成私有的

1.二叉搜索树的查找（递归）

private:
    //查找
	Node* _FindR(Node* root, const K& key)
	{
		if (root == nullptr)//没找到
		{
			return nullptr;
		}
 
		if (key < root->_key)//到左子树去找
		{
			FindR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找
		{
			FindR(root->_right, key);
		}
		else//找到了
		{
			return root;
		}
	}

2.二叉搜索树的插入（递归）

	//插入 加了&，root是_root的别名，修改root就直接修改到上一层调用，不用找父亲
	bool _InsertR(Node*& root, const K& key)
	{
		if (root == nullptr)//找到位置了
		{
			root = new Node(key);
			return true;
		}
		if (key < root->_key)//到左子树去找位置
		{
			_InsertR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找位置
		{
			_InsertR(root->_right, key);
		}
		else//已存在，无需插入
		{
			return false;
		}
	}

3.二叉搜索树的删除（递归）

递归删除：和二叉树的删除（非递归）一样，找到后的删除也有两种方式，递归和非递归

找到后的非递归删除：

    //插入 加了&，root是_root的别名，修改root就直接修改到上一层调用，不用找父亲	
    bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)//没找到
		{
			return false;
		}
		if (key < root->_key)//到左子树去找
		{
			_EraseR(root->_left, key);
		}
		else if (key > root->_key)//到右子树去找
		{
			_EraseR(root->_right, key);
		}
		else
		{
			//找到了，root就是要删除的节点
			if (root->_left == nullptr)//root左为空
			{
				Node* del = root;
				root = root->_right;
				delete del;
			}
			else if (root->_right == nullptr)//root右为空
			{
				Node* del = root;
				root = root->_left;
				delete del;
			}
			else//root左右都不为空
			{
				//找到右子树最左节点替换
				Node* minParent = root;
				Node* minRight = root->_right;
 
				while (minRight->_left)
				{
					minParent = minRight;
					minRight = minRight->_left;
				}
 
				//保存替换节点的值
				cur->_key = minRight->_key;
 
				//链接
				if (minParent->_left == minRight)
				{
					minParent->_left = minRight->_right;
				}
				else
				{
					minParent->_right = minRight->_right;
				}
 
				//删除
				delete minRight;
			}
			return true;
		}
	}

找到后的递归删除：

			else//root左右都不为空
			{				
                //找右子树最左节点
				Node* minRight = root->_right;
				while (minRight->_left)
				{
					minRight = minRight->_left;
				}
 
				//保存右子树最左节点的值
				K min = minRight->_key;
 
				//使用递归方法删除右子树最左节点
				_Erase(root->_right, min);
			}

四、二叉搜索树的默认成员函数

现在还剩下二叉搜索树的构造、拷贝构造、赋值运算符重载、析构函数。

1.构造

public:
	//构造函数需要将根初始化为空就行了
	BSTree()
		:_root(nullptr)
	{}

2.拷贝构造

拷贝构造利用递归调用子函数不断拷贝节点:

	//拷贝构造
	BSTree(const BSTree<K>& t)
	{
		_root = t.copy(t._root);
	}

在子函数处:

	Node* _copy(Node* root)
	{
		if (root == nullptr)//如果根为空，直接返回
		{
			return;
		}
 
		Node* copyNode = new Node(root->_key);//创建根节点
		copyNode->_left = _copy(root->_left);//递归拷贝左子树节点
		copyNode->_right = _copy(root->_right);//递归拷贝右子树节点
		
		return copyNode;//返回根
	}

3.赋值运算符重载

借助拷贝构造用现代写法写:

	//赋值运算符重载(现代写法)
	BSTree& operator=(const BSTree<K>& t)
	{
		swap(_root,t._root);
		return *this;
	}

4.析构

递归调用子函数去析构

	//析构
	~BSTree()
	{
		_Destroy(_root);
		_root = nullptr;
	}

在子函数处:

	_Destroy(root)
	{
		if (root == nullptr)
		{
			return;
		}
		_Destroy(root->_left);
		_Destroy(root->_right);
		delete root;
	}

五、K模型和KV模型搜索树

1.K模型搜索树

K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。
比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
1、以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
2、在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

2.KV模型搜索树

KV模型：每一个关键码key，都有与之对应的值Value，即<Key, Value>的键值对。该种方式在现实生活中非常常见：

1、比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文<word, chinese>就构成一种键值对；
2、再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出
现次数就是<word, count>就构成一种键值对。

改造二叉搜索树为KV结构的代码

#pragma once
#include<iostream>
#include<string>
using namespace std;

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		BSTreeNode<K, V>* _left;
		BSTreeNode<K, V>* _right;
		K _key;
		V _value;

		// pair<K, V> _kv;

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

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

			Node* parent = nullptr;
			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, value);
			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 cur;
		}

		bool Erase(const K& key)
		{
			Node* parent = nullptr;
			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(parent == nullptr)
						if (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_left)
							{
								parent->_left = cur->_right;
							}
							else
							{
								parent->_right = cur->_right;
							}
						}

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

						delete cur;
					}
					else
					{
						// 左右都不为空，替换法删除
						// 
						// 查找右子树的最左节点替代删除
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						swap(cur->_key, rightMin->_key);

						if (rightMinParent->_left == rightMin)
							rightMinParent->_left = rightMin->_right;
						else
							rightMinParent->_right = rightMin->_right;

						delete rightMin;
					}

					return true;
				}
			}

			return false;
		}

		void InOrder()
		{
			_InOrder(_root);
			cout << endl;
		}
	private:
		void _InOrder(Node* root)
		{
			if (root == nullptr)
			{
				return;
			}

			_InOrder(root->_left);
			cout << root->_key << ":" << root->_value << endl;
			_InOrder(root->_right);
		}
	private:
		Node* _root = nullptr;
	};

六、二叉搜索树性能分析

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

好了，今天的分享就到这里了
如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！
在这里插入图片描述

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

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

相关文章

TH方程学习（1）

TH方程学习（1）

一、背景介绍 根据CW方程的学习&#xff0c;CW方程的限制条件为圆轨道&#xff0c;不考虑摄动&#xff0c;二者距离相对较小。TH方程则可以将物体间的相对运动推广到椭圆轨道的二体运动模型&#xff0c;本部分将结合STK的仿真功能&#xff0c;联合考察TH方程的有用性&#xff…
阅读更多...
postman教程-7-文件上传接口

postman教程-7-文件上传接口

领取资料&#xff0c;咨询答疑&#xff0c;请➕wei: June__Go 上一小节我们学习了postman发送get请求的方法&#xff0c;本小节我们讲解一下postman文件上传接口的请求方法。 postman文件上传的方式大概有两种&#xff0c;一种是form-data类型上传文件&#xff0c;一种是bin…
阅读更多...
电脑丢失api-ms-win-crt-runtime-l1-1-0.dll的多种修复方法

电脑丢失api-ms-win-crt-runtime-l1-1-0.dll的多种修复方法

在计算机使用过程中&#xff0c;我们经常会遇到一些错误提示&#xff0c;其中之一就是“api-ms-win-crt-runtime-l1-1-0.dll丢失”。这个错误通常发生在Windows操作系统中&#xff0c;它表示一个动态链接库文件丢失或损坏。这个问题可能会导致某些应用程序无法正常运行&#xf…
阅读更多...
【CTF-Web】XXE学习笔记（附ctfshow例题）

【CTF-Web】XXE学习笔记（附ctfshow例题）

XXE 文章目录 XXE0x01 前置知识汇总XMLDTD &#xff08;Document Type Definition&#xff09; 0x02 XXE0x03 XXE危害0x04 攻击方式1. 通过File协议读取文件Web373(有回显)Web374(无回显) Web375Web376Web377Web378 0x01 前置知识汇总 XML 可扩展标记语言&#xff08;eXtensi…
阅读更多...
【YashanDB知识库】ODBC驱动类问题定位方法

【YashanDB知识库】ODBC驱动类问题定位方法

【标题】ODBC驱动类问题定位方法 【需求分类】故障分析 【关键字】ODBC 【需求描述】由于我们的ODBC接口目前尚不完善&#xff0c;经常会遇见ODBC接口能力不足导致应用功能无法运行的问题&#xff0c;需要定位手段确定底层是哪个接口报错 【需求原因分析】方便一线数据库管…
阅读更多...
【408真题】2009-27

【408真题】2009-27

“接”是针对题目进行必要的分析&#xff0c;比较简略&#xff1b; “化”是对题目中所涉及到的知识点进行详细解释&#xff1b; “发”是对此题型的解题套路总结&#xff0c;并结合历年真题或者典型例题进行运用。 涉及到的知识全部来源于王道各科教材&#xff08;2025版&…
阅读更多...
牛客热题：数据流中的中位数

牛客热题：数据流中的中位数

&#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;力扣刷题日记 &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&#x1f349;留言 文章目录 牛客热题&#xff1a;数据流中的中位数题目链接方法一…
阅读更多...
Marin说PCB之如何在主板上补偿链路中的走线的等长误差？

Marin说PCB之如何在主板上补偿链路中的走线的等长误差？

一场雨把我困在这里&#xff0c;你冷漠地看我没有穿雨衣淋成落汤鸡。今天刚刚出门时候看天气预报没有雨&#xff0c;于是我就没有带雨衣骑电动车去公司了&#xff0c;谁知道回来的路上被淋成狗了。天气预报就像是女人的脾气那样&#xff0c;不能完全相信的。 好了&#xff0c;我…
阅读更多...
MATLAB分类与判别模型算法： 快速近邻法（FastNN）分类程序【含Matlab源码 MX_005期】

MATLAB分类与判别模型算法： 快速近邻法（FastNN）分类程序【含Matlab源码 MX_005期】

算法思路介绍&#xff1a; 1. 数据准备阶段&#xff1a; 生成一个合成数据集 X&#xff0c;其中包含三个簇&#xff0c;每个簇分布在不同的区域。 定义聚类层数 L 和每个层次的子集数量 l。 2. 聚类阶段&#xff1a; 使用K均值聚类算法将初始数据集 X 分成 l 个簇。…
阅读更多...
大模型对齐方法笔记二：基于Rank的对齐方法RRHF和PRO

大模型对齐方法笔记二：基于Rank的对齐方法RRHF和PRO

文章目录 RRHFPRO将RLHF嫁接到PRO 参考资料 RRHF RRHF(Rank Responses to align Human Feedback)出自2023年4月的论文《RRHF: Rank Responses to Align Language Models with Human Feedback without tears》&#xff0c;是较早提出的不需要使用PPO来对齐人类偏好的方法。 设…
阅读更多...
五个超级好用的Prompt网站，让你的GPT效率碾压旁人！

五个超级好用的Prompt网站，让你的GPT效率碾压旁人！

五个超级好用的Prompt网站&#xff0c;让你的GPT效率碾压旁人&#xff01; 1. 150 Best ChatGPT Prompts for All Kinds of Workflow 该网站包含了150个能够显著提升工作流程效率的ChatGPT Prompt。从制作引人入胜的内容到简化项目&#xff0c;这些提示应该有助于将 ChatGPT …
阅读更多...
【高频】redis快的原因

【高频】redis快的原因

相关问题&#xff1a; 1.为什么Redis能够如此快速地进行数据存储和检索&#xff1f; 2.Redis作为内存数据库,其内存存储有什么优势吗? 3.Redis的网络模型有何特点,如何帮助提升性能? 一、问题回答 Redis使用了内存数据结构&#xff0c;例如字符串、哈希表、列表、集合、有…
阅读更多...
QT系列教程(5) 模态对话框消息传递

QT系列教程(5) 模态对话框消息传递

模态对话框接受和拒绝消息 我们创建一个模态对话框&#xff0c;调用exec函数后可以根据其返回值进行不同的处理&#xff0c;exec的返回值有两种&#xff0c;Qt的官方文档记录的为 QDialog::Accepted QDialog::RejectedAccepted 表示接受消息&#xff0c; Rejected表示拒绝消息…
阅读更多...
可视化大屏：随意堆数据，错！要主次分明、重点突出，动静结合。

可视化大屏：随意堆数据，错！要主次分明、重点突出，动静结合。

可视化大屏是一种展示数据的方式&#xff0c;它的设计应该遵循一些原则&#xff0c;以确保信息的传递和理解效果最佳。以下是一些关键点&#xff0c;可以帮助设计出主次分明、重点突出、动静结合的可视化大屏&#xff1a; 定义目标和重点&#xff1a; 在开始设计可视化大屏之前…
阅读更多...
【ESP32之旅】ESP32 PlatformIO 固件单独烧录

【ESP32之旅】ESP32 PlatformIO 固件单独烧录

背景 有时候使用PIO编写的代码需要发给客户去验证&#xff0c;相比较于发送源码直接发送bin文件&#xff0c;更加的安全而且高效。不用担心源码的泄漏&#xff0c;也不用帮客户配置PIO环境。 操作方法 1.编译 首先进行代码编译&#xff0c;如编译成功会在 .pio\build\airm2…
阅读更多...
LazyVim笔记

LazyVim笔记

回到上次编辑的位置 gi非常的方便。 neo-tree KeyDescriptionMode<leader>beBuffer Explorern<leader>eExplorer NeoTree (Root Dir)n<leader>EExplorer NeoTree (cwd)n<leader>feExplorer NeoTree (Root Dir)n<leader>fEExplorer NeoTree (c…
阅读更多...
【C language】统计某数中二进制1的个数

【C language】统计某数中二进制1的个数

题解&#xff1a;统计某数中二进制1的个数(取模法 看某位是1/0法 干掉最右边的1法) 目录 1.题目2.取模法3.看某位是1/04.干掉最右边的1 1.题目 题目&#xff1a;设计一个程序&#xff0c;统计某数中二进制1的个数 2.取模法 int main() {int num 15;int count 0;while (n…
阅读更多...
计算机毕业设计 | SpringBoot+vue仓库管理系统(附源码)

计算机毕业设计 | SpringBoot+vue仓库管理系统(附源码)

1&#xff0c;绪论 1.1 项目背景 随着电子计算机技术和信息网络技术的发明和应用&#xff0c;使着人类社会从工业经济时代向知识经济时代发展。在这个知识经济时代里&#xff0c;仓库管理系统将会成为企业生产以及运作不可缺少的管理工具。这个仓库管理系统是由&#xff1a;一…
阅读更多...
浏览器修改后端返回值

浏览器修改后端返回值

模拟接口响应和网页内容 通过本地覆盖可以模拟接口返回值和响应头&#xff0c;无需 mock 数据工具&#xff0c;比如&#xff08;Requestly&#xff09;&#xff0c;无需等待后端支持&#xff0c;快速复现在一些数据下的 BUG 等。在 DevTools 可以直接修改你想要的 Fetch/XHR 接…
阅读更多...
React-基础样式控制

React-基础样式控制

组件基础样式方案 React组件基础的样式控制有两种方式 1、行内样式&#xff08;不推荐&#xff09; 属性名是多个单词的需要使用驼峰写法 也可以把样式都提取到一个变量里&#xff0c;再赋值到style里 2、class类名控制
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023