• 数据结构之＜二叉搜索树＞

    目录

    🌈前言

    本篇文章进行数据结构中二叉搜索树的学习！！！

    🌸 二叉搜索树

    🌷1、二叉搜索树的概念

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

    1. 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值
    2. 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值
    3. 它的“左右子树”也分别为“二叉搜索树”
      在这里插入图片描述

    🌸2、二叉搜索树的接口

    前言：该文章将用下图作为插入删除操作的辅助
    在这里插入图片描述

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

    🌹2.1、二叉搜索树的定义和查找节点

    前言：二叉搜索树是由模板定的，节点存储的指针和对象可泛化

    template <typename K>
struct BSTNode
{
	BSTNode(const K& key = K())
		: left(nullptr)
		, right(nullptr)
		, _key(key)
	{}
	BSTNode<K>* left;
	BSTNode<K>* right;
	K _key;
};

template <typename K>
class BSTree
{
	typedef BSTNode<K> Node;
private:
	Node* root;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    注意：这里的节点跟二叉树完全一致，都是有二个指针指向左右孩子和存储一个值

    二叉搜索树查找指定值的思路：

    1. 从根开始比较，查找，比根大则往右边走查找，比根小则往左边走查找
    2. 最多查找高度次，如果走到空，还没有找到，则这个值不存在
    bool find(const K& key)
	{
		Node* cur = root;
		while (cur != nullptr)
		{
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return true;
		}
		return false;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    在这里插入图片描述

    第二种思路：使用递归进行查找 – 分治法，思路跟循环差不多
    3. 从根节点开始查找，大于根值走左子树，小于走右子树
    4. 缺陷：树不平衡且节点很多时，会导致递归太深 – 栈溢出

    bool Find(const K& key)
{
	return _find(root, key);
}

bool _Find(Node* _root, const K& key)
	{
		// 分治法 -- ①小于key走左子树 ②大于key走右子树 ③相等返回true ④走到最后没找到返回false
		if (_root == nullptr)
			return false;

		if (_root->_key > key) {
			return _Find(_root->left, key);
		}
		else if (_root->_key < key) {
			return _Find(_root->right, key);
		}
		else {
			return true;
		}
		return false;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    🌺2.2、二叉搜索树节点的插入

    二叉搜索树插入的思路：

    1. 树为空，则直接新增节点，赋值给root指针
    2. 树不空，按二叉搜索树性质（比根小走左，大走右）查找插入位置，插入新节点
    3. 插入的值相等时，返回false，二叉搜索树不允许数据冗余
    bool insert(const K& key)
	{
		// 思路：维护二个指针，一个指向根，一个为根父节点，比根的值小走左子树，反之右子树，相等返回false
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		Node* cur = root;
		Node* parent = nullptr;
		while (cur != nullptr)
		{
			if (cur->_key > key) {
				parent = cur;
				cur = cur->left;
			}
			else if (cur->_key < key) {
				parent = cur;
				cur = cur->right;
			}
			else
				return false;
		}
		
		// cur走到空时，判断根父节点的值比插入值大还是小，大插入右边，小插入左边
		Node* newNode = new Node(key);
		if (parent->_key > key)
			parent->left = newNode;
		else
			parent->right = newNode;

		return true;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    在这里插入图片描述

    第二种方法：使用递归进行插入，思路：

    1. 分治法：首先找到插入的位置(与find递归思路一样)，然后直接构造一个新的节点
    2. 重点是参数中的节点指针要加个引用，成为原节点指针的别名，找到插入位置后可以直接构造
    3. 缺陷：树不平衡且节点很多时，会导致递归太深 – 栈溢出
    bool Insert(const K& key)
	{
		return _insert(root, key);
	}

	// 这里根节点加引用说明_root是原指针别名，构造新节点直接在原指针上构造，不需要加一个父指针链接
	bool _Insert(Node*& _root, const K& key)
	{
		// 根为nullptr，直接构造一个节点
		if (_root == nullptr) {
			_root = new Node(key);
			return true;
		}
		// 分治法 -- ①小于key走左子树 ②大于key走右子树 ③相等返回false(不能数据冗余) ④构造节点链接
		if (_root->_key > key) {
			return _Insert(_root->left, key);
		}
		else if (_root->_key < key) {
			return _Insert(_root->right, key);
		}
		else {
			return false;
		}
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    🌻2.3、二叉搜索树节点的删除

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

    1. 要删除的结点无孩子结点（叶节点）
    2. 要删除的结点只有左孩子结点
    3. 要删除的结点只有右孩子结点
    4. 要删除的结点有左、右孩子结点

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

    • 情况2：删除该结点且使被删除节点的双亲结点指向被删除节点的左孩子结点–直接删除
    • 情况3：删除该结点且使被删除节点的双亲结点指向被删除结点的右孩子结点–直接删除
    • 情况4：在它的右子树中寻找中序下的第一个结点(关键码key最小)，用它的值填补到被删除节点中，再来处理该结点的删除问题–替换法删除
    bool erase(const K& key)
		{
			if (root == nullptr) {
				return false;
			}
			
			Node* parent = nullptr;
			Node* cur = root;
			while (cur != nullptr)
			{
				// 找删除节点和它的父节点
				if (cur->_key > key) {
					parent = cur;
					cur = cur->left;
				}
				else if (cur->_key < key) {
					parent = cur;
					cur = cur->right;
				}
				else 
				{
					// 找到后，情况二
					if (cur->right == nullptr) 
					{
						if (parent == nullptr) {
							root = cur->left;
						}
						else
						{
							if (cur == parent->left) {
								parent->left = cur->left;
							}
							else {
								parent->right = cur->left;
							}
						}
					}
					// 情况三
					else if (cur->left == nullptr)
					{
						if (parent == nullptr) {
							root = cur->right;
						}
						else
						{
							if (cur == parent->left) {
								parent->left = parent->right;
							}
							else {
								parent->right = cur->right;
							}
						}
					}
					else
					{
						// 情况四
						Node* RMin = cur->right;
						Node* Rparent = cur;

						while (RMin->left != nullptr)
						{
							Rparent = RMin;
							RMin = RMin->left;
						}
						cur->_key = RMin->_key;
						cur->_value = RMin->_value;
						if (Rparent->left == RMin) {
							Rparent->left = RMin->right;
						}
						else {
							Rparent->right = RMin->right;
						}
						cur = RMin;
					}
					delete cur;
					return true;
				}
			}
			return false;
		}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    图解：情况二和情况三

    在这里插入图片描述

    图解：情况四

    在这里插入图片描述

    第二种方法：使用递归进行删除，思路：

    1. 首先查找删除节点，与find基本一致，然后删除节点
    2. 将查找到的节点指向它的左/右节点 – 情况二或三
    3. 情况四还是要找左右子树中最大或最小的节点，然后交换值，最后通过递归来删除找到的最大最小值，递归复用前面情况二三的代码
    4. 缺陷：树不平衡且节点很多时，会导致递归太深 – 栈溢出
    bool Erase(const K& key)
	{
		return _Erase(root, key);
	}

bool _Erase(Node*& _root, const K& key)
	{
		// 根节点为空或没找到，返回false
		if (_root == nullptr) {
			return false;
		}

		// 找删除节点
		if (_root->_key > key) {
			return _Erase(_root->left, key);
		}
		else if (_root->_key < key) {
			return _Erase(_root->right, key);
		}
		else
		{
			// 保存删除节点，不保存会找不到原来的root，因为要删除root，就要让root的左/右孩子赋值给root
			Node* del = _root;

			// 找到后 ---- 分三种情况：①删除节点只有左孩子 ②删除节点只有有孩子 ③删除节点有左右孩子
			if (_root->right == nullptr) {
				_root = _root->left;
			}
			else if (_root->left == nullptr) {
				_root = _root->right;
			}
			else
			{
				// 找删除节点左子树中最大的值
				Node* left_Max = root->left;
				while (left_Max->right) {
					left_Max = left_Max->right;
				}
				std::swap(root->_key, left_Max->_key); // 替换它们的值
				return _Erase(root->left, key); // 在当前root的左子树中找已经替换值的节点，并且删除它
			}
			delete del;
			return true;
		}
		return false;
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    🌿2.4、完整代码（删除左右子树使用左子树最大值）

    template <typename K>
struct BSTNode
{
	BSTNode(const K& key = K())
		: left(nullptr)
		, right(nullptr)
		, _key(key)
	{}
	BSTNode<K>* left;
	BSTNode<K>* right;
	K _key;
};

template <typename K>
class BSTree
{
	typedef BSTNode<K> Node;
public:
	BSTree()
		: root(nullptr)
	{}
	BSTree(const BSTree<K>& s)
		: root(nullptr)
	{
		root = structure(s.root);
	}
	BSTree<K>& operator=(const BSTree<K>& bst)
	{
		Destory(root);
		root = structure(bst.root);
		return *this;
	}
	~BSTree()
	{
		Destory(root);
	}

	bool insert(const K& key)
	{
		// 思路：维护二个指针，一个指向根，一个为根父节点，比根的值小走左子树，反之右子树，相等返回false
		// 走到空时，判断根父节点的值比插入值大还是小，大插入右边，小插入左边
		if (root == nullptr)
		{
			root = new Node(key);
			return true;
		}

		Node* cur = root;
		Node* parent = nullptr;
		while (cur != nullptr)
		{
			if (cur->_key > key) {
				parent = cur;
				cur = cur->left;
			}
			else if (cur->_key < key) {
				parent = cur;
				cur = cur->right;
			}
			else
				return false;
		}

		Node* newNode = new Node(key);
		if (parent->_key > key)
			parent->left = newNode;
		else
			parent->right = newNode;

		return true;
	}

	bool erase(const K& key)
	{

		Node* cur = root;
		Node* parent = nullptr;
	
		while (cur != nullptr)
		{
			// 查找删除的节点的位置
			if (cur->_key > key) {
				parent = cur;
				cur = cur->left;
			}
			else if (cur->_key < key) {
				parent = cur;
				cur = cur->right;
			}
			else
			{
				// 找到后，删除时分四种情况 -- ①删除节点是一个叶节点 -- ②只有左节点 -- ③只有右节点 -- ④有左右节点
				// 删除节点只有左孩子时
				if (cur->right == nullptr)
				{
					// 当要删除根节点时，会造成parent空指针访问，可以把"根指针"直接指向他的"左孩子节点"
					if (parent == nullptr) {
						root = cur->left;
					}
					else
					{
						if (cur == parent->left) {
							parent->left = cur->left;
						}
						else {
							parent->right = cur->left;
						}
					}
					delete cur;
					cur = nullptr;
				}
				// 删除节点只有右孩子时
				else if (cur->left == nullptr)
				{
					// 当要删除根节点时，会造成parent空指针访问，可以把"根指针"直接指向他的"右孩子节点"
					if (parent == nullptr) {
						root = cur->right;
					}
					else
					{
						if (cur == parent->left) {
							parent->left = cur->right;
						}
						else {
							parent->right = cur->right;
						}
					}
					delete cur;
					cur = nullptr;
				}
				// 删除的节点有左右孩子 -- 替换法 -> 找删除节点中左子树最大的值或右子树最小的值，替换删除
				else 
				{
					Node* left_max = cur->left;
					// 删除节点可能是根节点且右子树为空，那么下面的循环将进不去
					Node* maxParent = cur;

					// 找删除节点左子树中最大值的节点(一直往右走遍历)
					while (left_max->right) {
						maxParent = left_max;
						left_max = left_max->right;
					}

					// 删除节点的值根left_max的值替换
					cur->_key = left_max->_key;
					// 删除left_max节点
					if (maxParent->left == left_max) {
						maxParent->left = left_max->left;
					}
					else {
						maxParent->left = left_max->right;
					}
					delete left_max;
					left_max = nullptr;
				}
				return true;
			}
		}
		return false;
	}

	bool find(const K& key)
	{
		Node* cur = root;
		while (cur != nullptr)
		{
			if (cur->_key > key)
				cur = cur->left;
			else if (cur->_key < key)
				cur = cur->right;
			else
				return true;
		}
		return false;
	}

	// 中序遍历
	void InOrder() 
	{ 
		_InOrder(root);
		cout << endl;
	}
private:
	// 使用前序遍历构造一颗新的SB树
	Node* structure(Node* _root)
	{
		if (_root == nullptr)
			return nullptr;

		Node* newTree = new Node(_root->_key);
		newTree->left = structure(_root->left);
		newTree->right = structure(_root->right);
		return newTree;
	}
	void Destory(Node* _root)
	{
		if (_root == nullptr)
			return;
		Destory(_root->left);
		Destory(_root->right);
		delete _root;
	}

	void _InOrder(Node* _root)
	{
		if (_root == nullptr)
			return;

		_InOrder(_root->left);
		cout << _root->_key << ' ';
		_InOrder(_root->right);
	}
private:
	Node* root;
};

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
    • 206
    • 207
    • 208
    • 209
    • 210
    • 211
    • 212
    • 213
    • 214
    • 215

    🌽2.5、 二叉搜索树的性能分析

    前言：插入和删除操作都必须先查找，查找效率代表了二叉搜索树中各个操作的性能

    • 对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索树平均查找长度是结点在二
      叉搜索树的深度的函数，即结点越深，则比较次数越多

    • 但对于同一个关键码集合，如果各关键码插入的次序不同，可能得到不同结构的二叉搜索树：
      在这里插入图片描述

    1. 最优情况下，二叉搜索树为完全二叉树(或者接近完全二叉树)，其平均比较次数为： l o g 2 N log_2 N log2​N
    2. 最差情况下，二叉搜索树退化为单支树(或者类似单支)，其平均比较次数为： N 2 \frac{N}{2} 2N​
    3. 问题：如果退化成单支树，二叉搜索树的性能就失去了。那能否进行改进，不论按照什么次序插
      入关键码，二叉搜索树的性能都能达到最优？
      答：后面我们学习到AVL树和红黑树就可以上场了，它们可以控制树的平衡

    🌾2.6、二叉搜索树的应用

    1. K模型：K模型即只有key作为关键码，结构中只需要存储Key即可关键码即为需要搜索到的值
      比如：给一个单词word，判断该单词是否拼写正确，具体方式如下：
    • 以词库中所有单词集合中的每个单词作为key，构建一棵二叉搜索树
    • 在二叉搜索树中检索该单词是否存在，存在则拼写正确，不存在则拼写错误。
    1. KV模型：每一个关键码key，都有与之对应的值Value，即的键值对。该种方式在现实生活中非常常见：
    • 比如英汉词典就是英文与中文的对应关系，通过英文可以快速找到与其对应的中文，英文单词与其对应的中文就构成一种键值对；
    • 再比如统计单词次数，统计成功后，给定单词就可快速找到其出现的次数，单词与其出现次数就是就构成一种键值对
    template <typename K, typename V>
	struct BSTNode
	{
		BSTNode(const K& key = K(), const V& value = V())
			: left(nullptr)
			, right(nullptr)
			, _key(key)
			, _value(value)
		{}
		BSTNode<K, V>* left;
		BSTNode<K, V>* right;
		K _key;
		V _value;
	};


	// KV版本 -- key value
	template <typename K, typename V>
	class BSTree
	{
		typedef BSTNode<K, V> Node;
	public:
		~BSTree() {
			Destory(root);
		}
		void InOrder() {
			_InOrder(root);
		}

		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 != nullptr)
			{
				if (cur->_key > key) {
					parent = cur;
					cur = cur->left;
				}
				else if (cur->_key < key) {
					parent = cur;
					cur = cur->right;
				}
				else {
					return false;
				}
			}

			Node* newNode = new Node(key, value);
			if (parent->_key > key) {
				parent->left = newNode;
			}
			else {
				parent->right = newNode;
			}
			return true;
		}

		bool erase(const K& key)
		{
			if (root == nullptr) {
				return false;
			}

			Node* parent = nullptr;
			Node* cur = root;

			while (cur != nullptr)
			{
				if (cur->_key > key) {
					parent = cur;
					cur = cur->left;
				}
				else if (cur->_key < key) {
					parent = cur;
					cur = cur->right;
				}
				else 
				{
					if (cur->right == nullptr) 
					{
						if (parent == nullptr) {
							root = cur->left;
						}
						else
						{
							if (cur == parent->left) {
								parent->left = cur->left;
							}
							else {
								parent->right = cur->left;
							}
						}
					}
					else if (cur->left == nullptr)
					{
						if (parent == nullptr) {
							root = cur->right;
						}
						else
						{
							if (cur == parent->left) {
								parent->left = parent->right;
							}
							else {
								parent->right = cur->right;
							}
						}
					}
					else
					{
						Node* RMin = cur->right;
						Node* Rparent = cur;

						while (RMin->left != nullptr)
						{
							Rparent = RMin;
							RMin = RMin->left;
						}
						cur->_key = RMin->_key;
						cur->_value = RMin->_value;
						if (Rparent->left == RMin) {
							Rparent->left = RMin->right;
						}
						else {
							Rparent->right = RMin->right;
						}
						cur = RMin;
					}
					delete cur;
					return true;
				}
			}
			return false;
		}

		Node* find(const K& key)
		{
			if (root == nullptr) {
				return nullptr;
			}

			Node* cur = root;
			while (cur != nullptr) 
			{
				if (cur->_key > key) {
					cur = cur->left;
				}
				else if (cur->_key < key) {
					cur = cur->right;
				}
				else {
					return cur;
				}
			}
			return nullptr;
		}

	private:
		void Destory(Node* _root)
		{
			if (_root == nullptr)
				return;
			Destory(_root->left);
			Destory(_root->right);
			delete _root;
		}

		void _InOrder(Node* _root)
		{
			if (_root == nullptr)
				return;

			_InOrder(_root->left);
			cout << _root->_key << ": " << _root->_value << endl;
			_InOrder(_root->right);
		}
	private:
		Node* root;
	};

	void Test()
	{
		string str[]{ "苹果", "雪梨", "榴莲", "苹果", "苹果", "雪梨", "香蕉", "苹果", "雪梨", "榴莲", "香蕉", "苹果" };
		BSTree<string, int> countTree;
		for (auto& f : str)
		{
			auto ret = countTree.find(f);
			if (ret == nullptr)
			{
				countTree.insert(f, 1);
			}
			else
			{
				ret->_value++;
			}
		}
		countTree.InOrder();
	}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    • 169
    • 170
    • 171
    • 172
    • 173
    • 174
    • 175
    • 176
    • 177
    • 178
    • 179
    • 180
    • 181
    • 182
    • 183
    • 184
    • 185
    • 186
    • 187
    • 188
    • 189
    • 190
    • 191
    • 192
    • 193
    • 194
    • 195
    • 196
    • 197
    • 198
    • 199
    • 200
    • 201
    • 202
    • 203
    • 204
    • 205
  • 相关阅读:
    docker常用命令
    视频号视频如何下载（WeChatVideoDownloader）
    Android Glide加载transform CenterCrop, CircleCrop ShapeableImageView圆形图并描边，Kotlin
    spring boot集成mybatis
    基于SqlSugar的开发框架循序渐进介绍（4）-- 在数据访问基类中对GUID主键进行自动赋值处理
    vue2虚拟滚动下拉选择器
    @RequiredArgsConstructor实现构造器注入
    OpenCV计算机视觉学习（14）——浅谈常见图像后缀（png, jpg, bmp）的区别（opencv读取语义分割mask的坑）
    多线程编程模式-Producer-consumer
    前端生态系统：构建现代Web应用的完整指南
  • 原文地址：https://blog.csdn.net/weixin_59400943/article/details/126067197