【C++庖丁解牛】二叉搜索树（Binary Search Tree，BST）

🍁你好，我是 RO-BERRY
📗 致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
🎄感谢你的陪伴与支持 ，故事既有了开头，就要画上一个完美的句号，让我们一起加油

在这里插入图片描述

目录

  • 1. 二叉搜索树概念
  • 2. 二叉搜索树操作
  • 3. 二叉搜索树的实现
    • 3.1 准备工作
      • 结点结构体BSTreeNode
      • 二叉搜索树BinarySearchTree
    • 3.2 函数体实现
      • 📖bool Insert(const K& key)
      • 📖bool Find(const K& key)
      • 📖打印二叉搜索树void InOrder()
      • 📖删除 Erase
      • 📖构造函数、析构函数、拷贝构造以及复制拷贝
    • 3.3 函数体实现(优化版)
      • 📖优化版insert函数
      • 📖优化版find函数
      • 📖优化版Erase函数
    • 3.4 源代码BinarySearchTree.h
  • 4. 二叉搜索树的应用
    • kv二叉树实现
  • 5. 二叉搜索树的性能分析

1. 二叉搜索树概念

二叉搜索树又称二叉排序树，它或者是一棵空树，或者是具有以下性质的二叉树:

若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
它的左右子树也分别为二叉搜索树

二叉搜索树（Binary Search Tree，简称BST）是种常用的数据结构，它是一棵二叉树，并且满足以下性质：

对任意节点，其左子树中的节点的值都小于该节点的值。
对于任意节点，其右子树中的所有节点的值都大于该节点的值。
左子树和右子树也都是二叉搜索树。
二叉搜索树的这种特性使得它在查找、插入和删除操作上具有高效性能。通过比较节点的值，可以快速定位到目标节点或者确定插入位置。

二叉搜索树的操作包括：

查找：从根节点开始，递归地比较目标值与当前节点的值，直到找到目标节点或者遍历到叶子节点。
插入：从根节点开始，递归地比较目标值与当前节点的值，根据大小关系选择左子树或右子树进行插入，直到找到合适的插入位置。
删除：删除操作比较复杂，需要考虑被删除节点的子节点情况。可以分为三种情况：被删除节点没有子节点、被删除节点只有一个子节点、被删除节点有两个子节点。
二叉搜索树的时间复杂度取决于树的高度，平均情况下为O(log n)，最坏情况下为O(n)。为了保持树的平衡，可以使用平衡二叉搜索树（如AVL树、红黑树）来优化性能。

在这里插入图片描述

2. 二叉搜索树操作

在这里插入图片描述

int a[] = {8, 3, 1, 10, 6, 4, 7, 14, 13};
  1. 二叉搜索树的查找
    a、从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找。
    b、最多查找高度次，走到到空，还没找到，这个值不存在。
  2. 二叉搜索树的插入
    插入的具体过程如下：
    a. 树为空，则直接新增节点，赋值给root指针
    b. 树不空，按二叉搜索树性质查找插入位置，插入新节点

在这里插入图片描述

  1. 二叉搜索
    首先查找元素是否在二叉搜索树中，如果不存在，则返回, 否则要删除的结点可能分下面四种情况：

a. 要删除的结点无孩子结点
b. 要删除的结点只有左孩子结点
c. 要删除的结点只有右孩子结点
d. 要删除的结点有左、右孩子结点

看起来有待删除节点有4中情况，实际情况a可以与情况b或者c合并起来，因此真正的删除过程如下：

情况b：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
情况c：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
情况d：在它的右子树中寻找中序下的第一个结点(关键码最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除

在这里插入图片描述

3. 二叉搜索树的实现

3.1 准备工作

结点结构体BSTreeNode

我们实现二叉搜索树需要定义其结点，定义其左右节点以及value，方便后续操作进行

template<class K>
struct BSTreeNode      //二叉树结点
{
	typedef BSTreeNode<K> Node;     //简化名称

	Node* _left;        //左节点
	Node* _right;       //右节点
	K _key;             //结点value

	BSTreeNode(const K& key)    //构造函数
		:_left(nullptr)
		,_right(nullptr)
		,_key(key)
	{}
};

二叉搜索树BinarySearchTree

template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> Node;    //节点名称简化
public:
	.....         //二叉搜索树函数接口
private:
	Node* _root = nullptr;        //省略了初始化在定义的时候就进行初始化
};

3.2 函数体实现

📖bool Insert(const K& key)

实现思路：

二叉搜索树的定义是左边的子结点必定小于父节点，右边的子结点必定大于父节点，所以我们采取key值与节点value比较，如果key大于节点value，则继续与节点右子节点比较；如果key小于节点value，则继续与节点左子节点比较，最终如果走到空的位置，则进行插入。

这里我们需要定义一个parent节点帮助我们定位最终插入后其父节点的位置，然后将父节点与新插入的结点进行连接，将父节点的value与key值比较，若key大于value，那么肯定是被插入到父节点的右子树里了；若key小于value，则反之。

另：我们要独自判断空树的情况，不然会出现程序崩溃；搜索二叉树的每一个节点数值不能一样，那么我们如果插入的key与某个value相等，也会返回false

实现代码：

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;    //父节点
		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);
		if (parent->_key < key)   //连接父节点
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

📖bool Find(const K& key)

实现思路：

左边的子结点必定小于父节点，右边的子结点必定大于父节点，所以我们采取key值与节点value比较，如果key大于节点value，则继续与节点右子节点比较；如果key小于节点value，则继续与节点左子节点比较，最终如果走到空的位置，则返回false，如果找到与key相等的value，则返回true。

实现代码：

	bool 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 true;
			}
		}
		return false;
	}

📖打印二叉搜索树void InOrder()

实现思路：

使用递归实现中序遍历，二叉搜索树的中序遍历其实输出出来是一个递增排序的数组，从根节点开始，访问其左子树，并进行打印，然后访问右子树进行打印。
这里用了一个巧妙的方法： 我们对二叉搜索树打印需要传入根节点位置，才能进行递归，但是根节点为私有成员，我们要么写一个GetRoot()函数获取到根节点位置，才能传入，我们在这里可以对其进行封装，在上面重新定义一个打印函数，然后在这个函数里面调用刚刚的打印函数，并传入root，这样就不用在调用的时候传入root了。

实现代码：

	void InOrder()       //巧妙调用输出函数
	{
		_InOrder(_root);
		cout << endl;
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

📖删除 Erase

实现思路：
二叉搜索树（Binary Search Tree，BST）的删除操作是指在BST中删除一个指定的节点。删除操作的模拟实现可以按照以下步骤进行：

首先，需要找到要删除的节点。从根节点开始，比较要删除的节点值与当前节点值的大小关系，如果相等则找到了要删除的节点，如果小于当前节点值，则继续在左子树中查找，如果大于当前节点值，则继续在右子树中查找。重复这个过程直到找到要删除的节点或者遍历到叶子节点为止。

如果找到了要删除的节点，需要考虑以下几种情况：

  1. 如果要删除的节点是叶子节点（没有子节点），直接删除即可。
  2. 如果要删除的节点只有一个子节点，将其子节点替代要删除的节点即可。
  3. 如果要删除的节点有两个子节点，需要找到其右子树中的最小节点（或者左子树中的最大节点），将其值替换到要删除的节点上，并将最小（或最大）节点删除。

实现删除操作时，需要注意维护BST的性质，即左子树中的所有节点值都小于当前节点值，右子树中的所有节点值都大于当前节点值。

实现代码：

	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 (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_right)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}

					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)  //右子树为空
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_right)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}

					delete cur;
					return true;
				}
				else                          //左右子树都不为空
				{
					// 替换法
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					cur->_key = rightMin->_key;

					if (rightMin == rightMinParent->_left)     //根节点
						rightMinParent->_left = rightMin->_right;    
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}

		return false;
	}

📖构造函数、析构函数、拷贝构造以及复制拷贝

这里直接实现，不再讲述原理，因为这一块比较基础了

	//强制生成默认构造
	BinarySearchTree() = default;

	BinarySearchTree(const BinarySearchTree<K>& t)   //拷贝构造函数
	{
		_root = Copy(t._root);
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newRoot = new Node(root->_key);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
		return new Root;
	}

	BinarySearchTree<K>& operator=(const BinarySearchTree<K>& t)    //赋值拷贝
	{
		swap(_root, t._root);
		return *this;
	}

	~BinarySearchTree()   //析构函数
	{
		Destroy(_root);
	}

3.3 函数体实现(优化版)

我们的优化主要用了封装的艺术

📖优化版insert函数

我们在上面的函数实现时需要判断最终在左子树还是在右子树，并且还要定义一个parent来存储其父节点，而我们对其进行优化，可以看到我们在函数参数里加了一个Node*& root，正是这个参数，我们使用了引用，就不需要再判断其是左子树还是右子树，也不用记录其父节点，因为引用就是别名，我们对其进行修改就是对这个指针进行修改，这里还用了递归，让我们的代码量大大减小

public:
	bool InsertR(const K& key)      //函数放在public便于访问
	{
		return _InsertR(_root, key);
	}
private:                              //函数的具体实现放在private
	bool _InsertR(Node*& root,const K& key)   //这里使用别名，修改的就是其本身，就不用判断左右节点了
	{
		if (root == nullptr)
		{
			root=new Node(key);
			return true;
		}
		if (root->_key < key)                 //小于key就遍历右子树
		{
			return _InsertR(root->_right, key);
	}
		else if (root->_key > key)            //大于key就遍历左子树
		{
			return _InsertR(root->_left, key);  
		}
		else
		{
			return false;
		}
	}

📖优化版find函数

public:
	bool FindR(const K& key)
	{
		return _FindR(_root, key);
	} 
private:
	bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

📖优化版Erase函数

public:
	bool EraseR(const K& key)
	{
		return _EraseR(_root, key);
	}
private:
	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;     //保存该节点便于删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

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

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

3.4 源代码BinarySearchTree.h

#pragma once

#include<iostream>
using namespace std;
template<class K>
struct BSTreeNode
{
	typedef BSTreeNode<K> Node;

	Node* _left;
	Node* _right;
	K _key;

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

template<class K>
class BinarySearchTree
{
	typedef BSTreeNode<K> Node;
public:
	//强制生成默认构造
	BinarySearchTree() = default;

	BinarySearchTree(const BinarySearchTree<K>& t)   //拷贝构造函数
	{
		_root = Copy(t._root);
	}
	Node* Copy(Node* root)
	{
		if (root == nullptr)
			return nullptr;

		Node* newRoot = new Node(root->_key);
		newRoot->_left = Copy(root->_left);
		newRoot->_right = Copy(root->_right);
		return new Root;
	}

	BinarySearchTree<K>& operator=(const BinarySearchTree<K>& t)    //赋值拷贝
	{
		swap(_root, t._root);
		return *this;
	}

	~BinarySearchTree()   //析构函数
	{
		Destroy(_root);
	}

	bool Insert(const K& key)
	{
		if (_root == nullptr)
		{
			_root = new Node(key);
			return true;
		}
		Node* cur = _root;
		Node* parent = nullptr;    //父节点
		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);
		if (parent->_key < key)   //连接父节点
		{
			parent->_right = cur;
		}
		else
		{
			parent->_left = cur;
		}
		return true;
	}

	bool 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 true;
			}
		}
		return false;
	}


	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 (cur == _root)
					{
						_root = cur->_right;
					}
					else
					{
						if (cur == parent->_right)
						{
							parent->_right = cur->_right;
						}
						else
						{
							parent->_left = cur->_right;
						}
					}

					delete cur;
					return true;
				}
				else if (cur->_right == nullptr)  //右子树为空
				{
					if (cur == _root)
					{
						_root = cur->_left;
					}
					else
					{
						if (cur == parent->_right)
						{
							parent->_right = cur->_left;
						}
						else
						{
							parent->_left = cur->_left;
						}
					}

					delete cur;
					return true;
				}
				else                          //左右子树都不为空
				{
					// 替换法
					Node* rightMinParent = cur;
					Node* rightMin = cur->_right;
					while (rightMin->_left)
					{
						rightMinParent = rightMin;
						rightMin = rightMin->_left;
					}

					cur->_key = rightMin->_key;

					if (rightMin == rightMinParent->_left)     //根节点
						rightMinParent->_left = rightMin->_right;    
					else
						rightMinParent->_right = rightMin->_right;

					delete rightMin;
					return true;
				}
			}
		}

		return false;
	}


	void InOrder()       //巧妙调用输出函数
	{
		_InOrder(_root);
		cout << endl;
	}

///
	bool 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:

	void Destroy(Node* root)
	{
		if (root == nullptr)
			return;

		Destroy(root->_left);
		Destroy(root->_right);
		delete root;
	}

	bool _EraseR(Node*& root, const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _EraseR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _EraseR(root->_left, key);
		}
		else
		{
			Node* del = root;     //保存该节点便于删除
			if (root->_right == nullptr)
			{
				root = root->_left;
			}
			else if (root->_left == nullptr)
			{
				root = root->_right;
			}
			else
			{
				Node* rightMin = root->_right;
				while (rightMin->_left)
				{
					rightMin = rightMin->_left;
				}

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

				return _EraseR(root->_right, key);
			}
			delete del;
			return true;
		}
	}

	bool _InsertR(Node*& root,const K& key)   //这里使用别名，修改的就是其本身，就不用判断左右节点了
	{
		if (root == nullptr)
		{
			root=new Node(key);
			return true;
		}
		if (root->_key < key)
		{
			return _InsertR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _InsertR(root->_left, key);
		}
		else
		{
			return false;
		}
	}



	bool _FindR(Node* root,const K& key)
	{
		if (root == nullptr)
			return false;
		if (root->_key < key)
		{
			return _FindR(root->_right, key);
		}
		else if (root->_key > key)
		{
			return _FindR(root->_left, key);
		}
		else
		{
			return true;
		}
	}

	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;
		_InOrder(root->_left);
		cout << root->_key << " ";
		_InOrder(root->_right);
	}

	Node* _root = nullptr;
};

4. 二叉搜索树的应用

  1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可，关键码即为需要搜索到的值。

比如:
给一个单词word，判断该单词是否拼写正确，具体方式如下：
以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。

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

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

kv二叉树实现

namespace key_value
{
	template<class K, class V>
	struct BSTreeNode
	{
		typedef BSTreeNode<K, V> Node;

		Node* _left;
		Node* _right;
		K _key;
		V _value;

		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:
		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 nullptr;
		}

		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 (cur == _root)
						{
							_root = cur->_right;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_right;
							}
							else
							{
								parent->_left = cur->_right;
							}
						}

						delete cur;
						return true;
					}
					else if (cur->_right == nullptr)
					{
						if (cur == _root)
						{
							_root = cur->_left;
						}
						else
						{
							if (cur == parent->_right)
							{
								parent->_right = cur->_left;
							}
							else
							{
								parent->_left = cur->_left;
							}
						}

						delete cur;
						return true;
					}
					else
					{
						// 替换法
						Node* rightMinParent = cur;
						Node* rightMin = cur->_right;
						while (rightMin->_left)
						{
							rightMinParent = rightMin;
							rightMin = rightMin->_left;
						}

						cur->_key = rightMin->_key;

						if (rightMin == rightMinParent->_left)
							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 << " ";
			_InOrder(root->_right);
		}

	private:
		Node* _root = nullptr;
	};
}

5. 二叉搜索树的性能分析

插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能。
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二叉搜索树的深度的函数，即结点越深，则比较次数越多。
但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
在这里插入图片描述

  1. 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： l o g 2 N log_2 N log2​N
  2. 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： N 2 \frac{N}{2} 2N​

问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
入关键码，二叉搜索树的性能都能达到最优？那么我们后续章节学习的AVL树和红黑树就可以上
场了。

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

结构体内存对齐 offsetof 枚举 联合体

结构体内存对齐 offsetof 枚举 联合体

文章目录 结构体结构体内存对齐结构体嵌套结构体内存对齐的原因修改默认对齐数设置默认对齐数 #pragma pack() offsetof() 是宏 offset偏移量 of是谁的偏移量。计算结构体成员相对于结构体的起始位置偏移量是几。 结构体传参值传递地址传递 位段枚举联合 联合体 共用体联合体大…
阅读更多...
【JS】深度学习JavaScript

【JS】深度学习JavaScript

&#x1f493; 博客主页&#xff1a;从零开始的-CodeNinja之路 ⏩ 收录文章&#xff1a;【JS】深度学习JavaScript &#x1f389;欢迎大家点赞&#x1f44d;评论&#x1f4dd;收藏⭐文章 目录 一:JavaScript1.1 JavaScript是什么1.2 JS的引入方式1.3 JS变量1.4 数据类型1.5 …
阅读更多...
LeetCode 热题 100 | 堆（二）

LeetCode 热题 100 | 堆（二）

目录 1 什么是优先队列 1.1 优先队列与堆的关系 1.2 如何定义优先队列 1.3 如何使用优先队列 1.4 如何设置排序规则 2 347. 前 K 个高频元素 2.1 第 2 步的具体实现 2.2 举例说明 2.3 完整代码 3 215. 数组中的第 K 个最大元素 - v2 菜鸟做题&#xff0c;语…
阅读更多...
【漏洞复现】科立讯通信指挥调度平台editemedia.php sql注入漏洞

【漏洞复现】科立讯通信指挥调度平台editemedia.php sql注入漏洞

漏洞描述 在20240318之前的福建科立讯通信指挥调度平台中发现了一个漏洞。该漏洞被归类为关键级别，影响文件/api/client/editemedia.php的未知部分。通过操纵参数number/enterprise_uuid可导致SQL注入。攻击可能会远程发起。 免责声明 技术文章仅供参考，任何个人和组织使…
阅读更多...
2024公认口碑最好的洗地机有哪些？若看重清洁力，这四款最值得买

2024公认口碑最好的洗地机有哪些？若看重清洁力，这四款最值得买

每当我们要清洁卫生时&#xff0c;是否总是感到腰酸背痛、疲劳不堪&#xff0c;甚至头昏眼花&#xff1f;地板是家中的重要门面&#xff0c;不容忽视的卫生焦点。如今&#xff0c;我们终于多了一位家务打扫的救星——家用洗地地机。一次操作&#xff0c;即可完成扫地除尘、地除…
阅读更多...
Git 分布式版本控制系统基本概念和操作命令

Git 分布式版本控制系统基本概念和操作命令

目录 Git 基本概念 功能特点 工作流程 操作命令 新建代码库 配置 增删文件 代码提交 分支 标签 查看信息 远程同步 撤销 其他 小结 Git Git 是一个开源的分布式版本控制系统&#xff0c;用于跟踪文件的变更历史。它最初由 Linux Torvalds 设计&#xff0c;用于…
阅读更多...
1+x中级题目练习复盘（八）

1+x中级题目练习复盘（八）

SQL 语句中进行 group by 分组时&#xff0c;可以不写 where 子句 在使用 select 语句进行查询分组时&#xff0c;如果希望去掉不满足条件的分组&#xff0c;使用 having 子句File 类的 isDirectory() 方法可以判断文件是否为目录 在使用 select 语句进行查询分组时&#xff0…
阅读更多...
二.寄存器

二.寄存器

1. 2. 例如&#xff1a;h即为high&#xff08;高位&#xff09;&#xff0c;l即为low&#xff08;低位&#xff09; 3.一个字是两个字节 4.在写一条汇编指令或一个寄存器的名称时不区分大小写。 5.al&#xff0c;ah&#xff0c;ax在接受汇编指令时&#xff0c;并不相等&…
阅读更多...
33-Java服务定位器模式 (Service Locator Pattern)

33-Java服务定位器模式 (Service Locator Pattern)

Java服务定位器模式 实现范例 服务定位器模式&#xff08;Service Locator Pattern&#xff09;用于想使用 JNDI 查询定位各种服务的时候考虑到为某个服务查找 JNDI 的代价很高&#xff0c;服务定位器模式充分利用了缓存技术在首次请求某个服务时&#xff0c;服务定位器在 JNDI…
阅读更多...
十三、MySQL基于GTID的半同步复制

十三、MySQL基于GTID的半同步复制

目录 一、MySQL半同步复制 一、三种复制方式比较 1、异步复制 2、同步复制 3、半同步复制 4、半同步复制比较 5、半同步复制的特点 二、搭建半同步复制 1、如果不清楚Plugin的目录&#xff0c;用如下查找&#xff1a; 2、所有数据库服务器&#xff0c;安装半同步插件…
阅读更多...
【Go实现】实践GoF的23种设计模式：解释器模式

【Go实现】实践GoF的23种设计模式：解释器模式

上一篇&#xff1a;【Go实现】实践GoF的23种设计模式&#xff1a;适配器模式 简单的分布式应用系统&#xff08;示例代码工程&#xff09;&#xff1a;https://github.com/ruanrunxue/Practice-Design-Pattern–Go-Implementation 简介 解释器模式&#xff08;Interpreter Pat…
阅读更多...
【STM32嵌入式系统设计与开发】——6矩阵按键应用（4x4）

【STM32嵌入式系统设计与开发】——6矩阵按键应用（4x4）

这里写目录标题 一、任务描述二、任务实施1、SingleKey工程文件夹创建2、函数编辑&#xff08;1&#xff09;主函数编辑&#xff08;2&#xff09;LED IO初始化函数(LED_Init())&#xff08;3&#xff09;开发板矩阵键盘IO初始化&#xff08;ExpKeyBordInit()&#xff09;&…
阅读更多...
JVM本地方法

JVM本地方法

本地方法接口 NAtive Method就是一个java调用非java代码的接口 本地方法栈&#xff08;Native Method Statck&#xff09; Java虚拟机栈用于管理Java方法的调用&#xff0c;而本地方法栈用于管理本地方法的调用。 本地方法栈&#xff0c;也是线程私有的。 允许被实现成固定或…
阅读更多...
Matlab|基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究

Matlab|基于分布式ADMM算法的考虑碳排放交易的电力系统优化调度研究

目录 1 主要内容 目标函数 计算步骤 节点系统 2 部分代码 3 程序结果 4 下载链接 1 主要内容 程序完全复现文献《A Distributed Dual Consensus ADMM Based on Partition for DC-DOPF with Carbon Emission Trading》&#xff0c;建立了一个考虑碳排放交易的最优模型&am…
阅读更多...
【测试开发学习历程】MySQL分组查询与子查询 + MySQL表的联结操作

【测试开发学习历程】MySQL分组查询与子查询 + MySQL表的联结操作

目录 1 MySQL分组查询与子查询 1.1 数据分组查询 1.2 过滤分组 1.3 分组结果排序 1.4 select语句中子句的执行顺序 1.5 子查询 2 MySQL表的联结操作 2.1 关系表 2.2 表联结 2.3 笛卡尔积 2.4 内部联结 2.5 外联结 2.6 自联结 2.7 组合查询 1 MySQL分组查询与子查询…
阅读更多...
Java学习路线一条龙

Java学习路线一条龙

说在前面 讲真&#xff0c;虽然我是正规计算机专业出身&#xff0c;但十多年来&#xff0c;Java这语言和它那一大堆配套的工具、框架&#xff0c;变化得太快了。 我也是一边学新的&#xff0c;一边扔旧的&#xff0c;忙得不可开交。 现在回想起来&#xff0c;走过的弯路、浪费…
阅读更多...
2024年【危险化学品经营单位安全管理人员】新版试题及危险化学品经营单位安全管理人员模拟考试题

2024年【危险化学品经营单位安全管理人员】新版试题及危险化学品经营单位安全管理人员模拟考试题

题库来源&#xff1a;安全生产模拟考试一点通公众号小程序 危险化学品经营单位安全管理人员新版试题考前必练&#xff01;安全生产模拟考试一点通每个月更新危险化学品经营单位安全管理人员模拟考试题题目及答案&#xff01;多做几遍&#xff0c;其实通过危险化学品经营单位安…
阅读更多...
C++默认构造函数（二）

C++默认构造函数（二）

目录 构造函数补充 构造函数初始化列表的使用 赋值运算符重载函数 运算符重载函数介绍 运算符重载函数的使用 赋值运算符重载函数 赋值运算符重载函数的使用 拷贝构造函数和赋值运算符重载函数 重载前置和后置 前置 后置 重载流插入<<与流提取>> 流插…
阅读更多...
ngrok实现内网穿透

ngrok实现内网穿透

在使用jenkins进行自动化部署时&#xff0c;需要设置github的webhook钩子来触发构建&#xff0c;由于jenkins运行在自己的电脑上&#xff0c;因此需要通过内网穿透来接受http请求。 Install ngrok via Homebrew with the following command: brew install ngrok/ngrok/ngrokP…
阅读更多...
微信小程序开发学习笔记——4.2showModal和showLoading界面交互操作

微信小程序开发学习笔记——4.2showModal和showLoading界面交互操作

>>跟着b站up主“咸虾米_”学习微信小程序开发中&#xff0c;把学习记录存到这方便后续查找。 课程连接&#xff1a;https://www.bilibili.com/video/BV19G4y1K74d?p27&vd_source9b149469177ab5fdc47515e14cf3cf74 一、showModal 显示模态对话框 1、属性 https:/…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站