• C++ 数据结构--二叉搜索树的实现

    文章目录

    前言

    二叉搜索树（BST，Binary Search Tree），也称二叉排序树，二叉查找树。若不是空树，二叉搜索树满足以下性质

    1.左子树的所有节点小于根节点
    2.右子树的所有节点大于根节点
    3.左右子树都满足以上性质

    在这里插入图片描述
    二叉搜索树多用来查找，时间效率是O(n)，效率非常高，即使是最坏情况，查找次数也是高度次。

    类模板的声明

    template <class K>
struct BSTreeNode
{
	BSTreeNode(K key)
	{
		_key = key;
		_left = nullptr;
		_right = nullptr;
	}

	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key; // 数据域
};

template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
private:
	Node* CopyTree(Node* root); // 拷贝一颗树，返回树的根节点
	void DestoryTree(Node* root);   //  释放每个节点
	bool _FindR(const K& key, Node* cur);
	bool _InsertR(const K& key, Node*& cur);
	bool _EraseR(const K& key, Node*& cur);

public:
	// 构造和析构
	BSTree() = default;         // 强制使用默认生成的构造
	BSTree(const BSTree& t) { _root = CopyTree(t._root); }
	~BSTree() { DestoryTree(_root); _root = nullptr; }
	const BSTree& operator=(BSTree t);
	
	// 修改
	bool Insert(const K& key);
	bool InsertR(const K& key) { return _InsertR(key, _root); }
	bool Find(const K& key);
	bool FindR(const K& key) { return _FindR(key, _root); }
	bool Erase(const K& key);
	bool EraseR(const K& key) { return _EraseR(key, _root); }

	// 打印
	void PrintTree() { _PrintTree(_root); }
	void _PrintTree(Node* root);
private:
	Node* _root = nullptr;
};

    • 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

    构造和析构

    在这里插入图片描述
    二叉搜索树的构造函数，在成员列表给_root缺省值nulllptr就行了。但后面要实现拷贝构造，因为拷贝构造也属于构造函数，不显式写构造函数编译器不会自动生成默认构造，在构造函数后面给缺省值default是C++11的语法，能强制构造函数使用编译器默认生成的。

    拷贝构造函数：调用子函数CopyTree进行递归，一个参数是根节点的指针。

    • 假设拷贝的树没有节点，判断根节点为空，返回nullptr
    • 如果只有一个节点，根据该节点的key值new一个新的节点并且返回新的节点
    • 如果节点数大于一个节点，在拷贝新的根节点后，拷贝根节点子树的根节点，并链接到根节点上。
    template <class K>
typename::BSTree<K>::Node* BSTree<K>::CopyTree(Node* root)
{
	if (root == nullptr)
		return nullptr;
	
	Node* copyNode = new Node(root->_key);
	copyNode->_left = CopyTree(root->_left);
	copyNode->_left = CopyTree(root->_right);

	return copyNode;
}

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

    拷贝构造调用这个子函数即可
    在这里插入图片描述
    析构函数也需要调用子函数Destroy递归释放每个节点，递归函数的逻辑和后续遍历相似：先释放左右子树的节点，最后再释放自己。

    template <class K>
void BSTree<K>::DestroyTree(Node* root)
{
	if (root == nullptr)
		return;
	
	DestroyTree(root->_left);
	DestroyTree(root->_right);
	
	delete root;
}

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

    在这里插入图片描述
    赋值就调用拷贝构造，拷贝出参数t，再交换t和当前树（形参在传递时会调用拷贝构造生成t）

    template <class K>
const BSTree<K>& BSTree<K>::operator=(BSTree t)
{
	std::swap(_root, t._root);

	return *this;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    修改（非递归）

    在这里插入图片描述
    插入，查找和删除。插入的思路：将key值和节点的key值比较，大于往右走，小于往左走，直到走到nullptr，new新的节点。但是原来的树并没有被修改，所以在迭代的过程中需要记录父母，当走到空时判断父母的key值和参数key值的关系，从而判断要将新节点链接到父母的左边还是右边。

    template <class K>
bool BSTree<K>::Insert(const K& key)
{
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}
	
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur) // cur走到空停止
	{
		if (key < cur->_key) // 小于往左
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_key) // 大于往右
		{
			parent = cur;
			cur = cur->_right;
		}
		else
		{
			return false; // 不插入相等的key
		}
	}

	if (key < parent->_key)
	{
		parent->_left = new Node(key);
		return true;
	}
	else
	{
		parent->_right = new Node(key);
		return ture;
	}
}

    • 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

    查找的思路和插入一样，走到else的地方说明找到了，返回true，循环结束还没找到，返回false

    template <class K>
bool BSTree<K>::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 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

    删除就有一点麻烦，分为两种情况，一种是要删除的节点没有子节点或只有一个字节，在找要被删除的节点时需要记录父母，然后让父母的左或右指向被删除节点的子节点（如果被删除节点左为空，父母指向右，右为空，父母指向左）。但删除根节点时，由于根节点没有父母，所以直接对_root进行修改即可。

    另一种情况就是被删节点有两个孩子，需要找出被删节点的左树最大或者右树最小的节点，替换被删节点，不删除被删除节点，而是删除左树最大或右树最小节点（转换成第一种情况）。替换节点后，树依然满足搜索二叉树的性质（被删节点的左树最大，小于被删节点，大于左树所有节点，被删节点小于右树所有节点，其左树最大也小于右树所有节点）。

    template <class K>
bool BSTree<K>::Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key)
		{
			parent = cur;
			cur = cur->_left;
		}
		else if (key > cur->_right)
		{
			parent = cur;
			cur = cur->_right;
		}
		else // 找到的情况
		{
			// 被删节点
			if (cur->_left == nullptr)
			{
				if (cur == _root) // 根节点无父节点
				{
					_root = _root->_right;
					delete cur;
				}
				else
				{
					if (key < parent->_key) // cur在parent的左边
					{
						parent->_left = cur->_right;
						delete cur;
					} 
					else
					{
						parent->_right = cur->_right;
						delete cur;
					} 
				}
				return true;
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root) // 根节点无父节点
				{
					_root = _root->_left;
					delete cur;
				}
				else
				{
					if (key < parent->_key) // cur在parent的左边
					{
						parent->_left = cur->_left;
						delete cur;
					} 
					else
					{
						parent->_right = cur->_left;
						delete cur;
					} 
				}
				return true;
			}
			else // 有两子节点
			{
				Node* leftMax = cur->_left;
				Node* maxParent = cur;
				while (leftMax->_right) // 找左树最大
				{
					maxParent = leftMax;
					leftMax = leftMax->_right;
				}
				cur->_key = leftMax->_key;
				// 删除leftMax节点
				if (maxParent ->_left == leftMax)
				{
					maxParent ->_left = leftMax->_left;
					delete leftMax;
				}
				else
				{
					maxParent ->_right = leftMax->_left;
					delete leftMax;
				}
			}
		}
	}
	// 循环结束，表示还没找到
	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
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91

    修改（递归）

    在这里插入图片描述
    和非递归相比，递归就来的好写的多，但理解也偏难。用递归的思想插入：如果当前节点为空，直接插入，不为空判断，小于当前节点，往左。大于当前节点，往右。但递归需要调用子函数（主函数直接说插入的key，但递归需要判断节点是否为空来决定是否要继续递归，所以子函数比主函数多了一个参数–节点的指针）

    template <class K>
bool BSTree<K>::_InsertR(const K& key, Node*& cur)
{
	if (cur == nullptr)
	{
		cur = new Node(key);
		return true;
	}
	if (key < cur->_key)
	{
		return _InsertR(key, cur->_left);
	}
	else if (key > cur->_key)
	{
		return _InsertR(key, cur->_right);
	}
	else
	{
		return false;
	}
}

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

    主函数调用子函数即可在这里插入图片描述
    注意：非递归需要使用parent记录被删除节点的父节点，但递归却不用，原因是节点指针使用了引用。

    查找的思路和插入一样，比大小判断往左还是往右走，相等返回true

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

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

    在这里插入图片描述
    删除的递归就比较复杂，但思路和前两个类似，在找到节点时分为两种情况。只有一个节点或没有节点的情况不用设置parent，使用引用，这样的话也不用判断是否是根节点。遇到有两个子节点的情况，找左树最小就要设置parent了，虽然cur是引用，但假设找leftMax也用引用，leftMax一直都是刚开始被定义时的引用，引用的对象没有被修改，具体的原理在我的C++入门有介绍。

    template <class K>
bool BSTree<K>::_Erase(const K& key, Node*& cur)
{
	if (cur == nullptr)
	{
		return false;
	}
	if (key < cur->_key)
	{
		return _Erase(key, cur->_left);
	}
	else if (key > cur->_key)
	{
		return _Erase(key, cur->_right);
	}
	else
	{
		if (cur->_left == nullptr)
		{
			Node* del = cur;
			cur = cur->_right;
			delete del;
		}
		else if (cur->_right == nullptr)
		{
			Node* del = cur;
			cur = cur->_left;
			delete del;
		}
		else
		{
			Node* leftMax = cur->_left;
			Node* maxParent = cur;
			while (leftMax->_right)
			{
				parent = leftMax;
				leftMax = leftMax->_right;
			}
			cur->_key = leftMax->_key;
			if (maxParent ->_left == leftMax)
			{
				maxParent ->_left = leftMax->_left;
				delete leftMax;
			}
			else
			{
				maxParent ->_right = leftMax->_left;
				delete leftMax;
			}
		}
		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
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53

    对于有两个子节点的情况，还有一种写法，不设置parent，找到leftMax后不覆盖原来cur的key值，而交换两者的值，调用自己，删除被交换后的节点。但交换后的整颗树不满足搜索树的性质，但cur的左树是满足的，所以传的根节点为左子树的根节点。

    else
{
	Node* leftMax = cur->_left;
	while (leftMax->_right)
	{
		leftMax = leftMax->_right;
	}
	swap(cur->_key, leftMax->key); // 交换key值
	_Erase(key, cur->_left);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    hpp文件

    最后放出整个文件的代码

    #define _CRT_SECURE_NO_WARNINGS 1

#pragma once
#include 
using std::cout;

template <class K>
struct BSTreeNode
{
	BSTreeNode(K key)
	{
		_key = key;
		_left = nullptr;
		_right = nullptr;
	}

	BSTreeNode<K>* _left;
	BSTreeNode<K>* _right;

	K _key; // 数据域
};

template <class K>
class BSTree
{
	typedef BSTreeNode<K> Node;
private:
	Node* CopyTree(Node* root); // 拷贝一颗树，返回树的根节点
	void DestroyTree(Node* root);   //  释放每个节点
	bool _FindR(const K& key, Node* cur);
	bool _InsertR(const K& key, Node*& cur);
	bool _EraseR(const K& key, Node*& cur);

public:
	// 构造和析构
	BSTree() = default;         // 强制使用默认生成的构造
	BSTree(const BSTree& t) { _root = CopyTree(t._root); }
	~BSTree() { DestroyTree(_root); _root = nullptr; }
	const BSTree& operator=(BSTree t);
	
	// 修改
	bool Insert(const K& key);
	bool InsertR(const K& key) { return _InsertR(key, _root); }
	bool Find(const K& key);
	bool FindR(const K& key) { return _FindR(key, _root); }
	bool Erase(const K& key);
	bool EraseR(const K& key) { return _EraseR(key, _root); }

	// 打印
	void PrintTree() { _PrintTree(_root); }
	void _PrintTree(Node* root);
private:
	Node* _root = nullptr;
};


template <class K>
bool BSTree<K>::Insert(const K& key)
{
	// 空树直接插入
	if (_root == nullptr)
	{
		_root = new Node(key);
		return true;
	}

	// 树不为空
	Node* cur = _root;
	Node* parent = nullptr;
	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指向空，将节点插入到cur的位置
	if (key < parent->_key) // 判断cur是parent的哪个孩子
	{
		parent->_left = new Node(key);
	}
	else
	{
		parent->_right = new Node(key);
	}
	return true;
}

template <class K>
bool BSTree<K>::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 true;
		}
	}

	// 循环结束还没找到就是没有这个数
	return false;
}

template <class K>
bool BSTree<K>::Erase(const K& key)
{
	Node* cur = _root;
	Node* parent = nullptr;
	while (cur)
	{
		if (key < cur->_key) // 当前值较小，向左走
		{
			parent = cur;
			cur = cur->_left;
		}

		else if (key > cur->_key)
		{
			parent = cur;
			cur = cur->_right;
		}
		else // 找到删除
		{
			if (cur->_left == nullptr)
			{
				if (cur == _root)
				{
					_root = _root->_right;
					delete cur;
					return true;
				}
				else
				{
					if (parent->_left == cur)
					{
						parent->_left = cur->_right;
						delete cur;
						return true;
					}
					else
					{
						parent->_right = cur->_right;
						delete cur;
						return true;
					}
				}
			}
			else if (cur->_right == nullptr)
			{
				if (cur == _root)
				{
					_root = _root->_left;
					delete cur;
					return true;
				}
				else
				{
					if (parent->_left == cur) // 父节点的左边是cur
					{
						parent->_left = cur->_left;
						delete cur;
						return true;
					}
					else
					{
						parent->_right = cur->_left;
						delete cur;
						return true;
					}
				}
			}
			else // 两边都不为空，找其他节点替换（左数最大，右树最小）
			{
				Node* maxLeft = cur->_left;
				Node* maxParent = cur;
				while (maxLeft->_right) // 找左数最大
				{
					maxParent = maxLeft;
					maxLeft = maxLeft->_right;
				}
				// 替换cur的值，相当于删除
				cur->_key = maxLeft->_key;

				// maxLeft是左子树最右边的，所以right为空，只有left可能存在节点
				if (maxParent->_left == maxLeft)
				{
					maxParent->_left = maxLeft->_left;
				}
				else
				{
					maxParent->_right = maxLeft->_left;
				}
				delete maxLeft;
			}
		}
	}

	// 循环结束还没找到就是没有这个数
	return false;
}

template <class K>
typename::BSTree<K>::Node* BSTree<K>::CopyTree(Node* root)
{
	if (root == nullptr)
		return nullptr;

	Node* copyNode = new Node(root->_key);
	copyNode->_left = CopyTree(root->_left); // 递归调用，拷贝左右子树
	copyNode->_right = CopyTree(root->_right);

	return copyNode;
}

template <class K>
const BSTree<K>& BSTree<K>::operator=(BSTree t)
{
	std::swap(_root, t._root);

	return *this;
}

template <class K>
void BSTree<K>::DestroyTree(Node* root)
{
	if (root == nullptr)
		return;

	DestroyTree(root->_left);
	DestroyTree(root->_right);

	delete root;
}

template <class K>
void BSTree<K>::_PrintTree(Node* cur)
{
	if (cur == nullptr)
		return;

	_PrintTree(cur->_left);
	cout << cur->_key << ' ';
	_PrintTree(cur->_right);
}

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


template <class K>
bool BSTree<K>::_InsertR(const K& key, Node*& cur)
{
	if (cur == nullptr)
	{
		cur = new Node(key);
		return true;
	}
	if (key < cur->_key)
	{
		return _InsertR(key, cur->_left);
	}
	else if (key > cur->_key)
	{
		return _InsertR(key, cur->_right);
	}
	else
	{
		return false;
	}
}

template <class K>
bool BSTree<K>::_EraseR(const K& key, Node*& cur)
{
	if (cur == nullptr)
		return false;

	if (key < cur->_key)
	{
		return _EraseR(key, cur->_left);
	}
	else if (key > cur->_key)
	{
		return _EraseR(key, cur->_right);
	}
	else 
	{
		// cur是要删除的节点
		if (cur->_left == nullptr)
		{
			Node* del = cur;
			cur = cur->_right;
			delete del;
		}
		else if (cur->_right == nullptr)
		{
			Node* del = cur;
			cur = cur->_left;
			delete del;
		}
		else // 两子节点都不为空
		{
			Node* maxLeft = cur->_left;
			Node* maxParent = cur;
			while (maxLeft->_right)
			{
				maxParent = maxLeft;
				maxLeft = maxLeft->_right;
			}

			cur->_key = maxLeft->_key;

			if (maxParent->_left == maxLeft)
			{
				maxParent->_left = maxLeft->_left;
			}
			else
			{
				maxParent->_right = maxLeft->_left;
			}
			delete maxLeft;
		}
		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
    • 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
    • 216
    • 217
    • 218
    • 219
    • 220
    • 221
    • 222
    • 223
    • 224
    • 225
    • 226
    • 227
    • 228
    • 229
    • 230
    • 231
    • 232
    • 233
    • 234
    • 235
    • 236
    • 237
    • 238
    • 239
    • 240
    • 241
    • 242
    • 243
    • 244
    • 245
    • 246
    • 247
    • 248
    • 249
    • 250
    • 251
    • 252
    • 253
    • 254
    • 255
    • 256
    • 257
    • 258
    • 259
    • 260
    • 261
    • 262
    • 263
    • 264
    • 265
    • 266
    • 267
    • 268
    • 269
    • 270
    • 271
    • 272
    • 273
    • 274
    • 275
    • 276
    • 277
    • 278
    • 279
    • 280
    • 281
    • 282
    • 283
    • 284
    • 285
    • 286
    • 287
    • 288
    • 289
    • 290
    • 291
    • 292
    • 293
    • 294
    • 295
    • 296
    • 297
    • 298
    • 299
    • 300
    • 301
    • 302
    • 303
    • 304
    • 305
    • 306
    • 307
    • 308
    • 309
    • 310
    • 311
    • 312
    • 313
    • 314
    • 315
    • 316
    • 317
    • 318
    • 319
    • 320
    • 321
    • 322
    • 323
    • 324
    • 325
    • 326
    • 327
    • 328
    • 329
    • 330
    • 331
    • 332
    • 333
    • 334
    • 335
    • 336
    • 337
    • 338
    • 339
    • 340
    • 341
    • 342
    • 343
    • 344
    • 345
    • 346
    • 347
    • 348
    • 349
    • 350
    • 351
    • 352
    • 353
    • 354
    • 355
    • 356
    • 357
    • 358
    • 359
    • 360
    • 361
    • 362
    • 363
    • 364
    • 365
    • 366
  • 相关阅读:
    中山大学软件工程学院区块链课程作业——信息传递网络与价值传递网络的区别和联系是什么？未来价值传递网络上可能产生的新业务有哪些？
    python入门基础-数据类型&有序序列和无序序列；
    Android-P夜间模式
    NIO总结文——一篇读懂NIO整个流程
    共享单车之数据可视化
    JavaScript的懒加载处理
    数据结构（C语言） 实验-栈与字符串
    Docker入门
    检测图像的圆形 检测直线 Hough变换检测直线 圆形检测 圆心半径检测 -matlab
    盘点3种Python网络爬虫过程中的中文乱码的处理方法
  • 原文地址：https://blog.csdn.net/weixin_61432764/article/details/126390262