从前慢现在也慢

这个屌丝很懒，什么也没留下！

热门标签

数据结构篇九：AVL树

作者：从前慢现在也慢 | 2024-03-08 03:27:11

踩

数据结构篇九：AVL树

文章目录

前言
1. AVL树的概念
2. AVL树节点的定义
3. AVL树的插入
4. AVL树的验证
- 4.1 验证其为二叉搜索树
- 4.2 验证其为平衡树
5. AVL树的删除
6. AVL树的性能
7. 代码实现
- 7.1 AVL.h
- 7.2 Test.cpp
8. 总结

前言

在二叉搜索树中我们发现这种情况下查询效率依旧很低下：
在这里插入图片描述
如果插入的顺序有序，那么就会变成成单支树，二叉搜索树的性能就失去了，而AVL树和红黑树就是为了解决这个问题而发明的。本章主要讲解的是AVL树，下一篇文章将会讲解红黑树。

1. AVL树的概念

二叉搜索树虽可以缩短查找的效率，但如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺序表中搜索元素，效率低下。因此，两位俄罗斯的数学家G.M.Adelson-Velskii和E.M.Landis在1962年发明了一种解决上述问题的方法：当向二叉搜索树中插入新结点后，如果能保证每个结点的左右子树高度之差的绝对值不超过1(需要对树中的结点进行调整)，即可降低树的高度，从而减少平均搜索长度。
一棵AVL树或者是空树，或者是具有以下性质的二叉搜索树：

它的左右子树都是AVL树
左右子树高度之差(简称平衡因子)的绝对值不超过1(-1/0/1）（平衡因子：某一结点的右子树的高度减左子树的高度）

如果一棵二叉搜索树是高度平衡的，它就是AVL树。如果它有n个结点，其高度可保持在 $O(log_2 n)$ ，搜索时间复杂度O( $log_2 n$ )。
AVL树的解决方法其实是将树平衡因子超过1的树进行旋转，我们来看个例子：

这样就将一个平衡因子为了2的树变成了平衡因子为0的树，如此就完美的解决了单支树的问题。

2. AVL树节点的定义

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;

	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

AVL树我们采用的是三叉链，相比较二叉链多存储了父亲节点，它会更好的帮助我们进行调整节点的操作。

3. AVL树的插入

AVL树就是在二叉搜索树的基础上引入了平衡因子，因此AVL树也可以看成是二叉搜索树。那么AVL树的插入过程可以分为两步：

按照二叉搜索树的方式插入新节点
调整节点的平衡因子

先按照二叉搜索树的规则将节点插入到AVL树中
新节点插入后，AVL树的平衡性可能会遭到破坏，此时就需要更新平衡因子，并检测是否破坏了AVL树的平衡性cur插入后，parent的平衡因子一定需要调整，在插入之前，parent 平衡因子分为三种情况：-1，0, 1, 分以下两种情况：
如果cur插入到parent的左侧，只需给parent的平衡因子-1即可
如果cur插入到parent的右侧，只需给parent的平衡因子+1即可

此时：parent的平衡因子可能有三种情况：0，正负1，正负2

如果parent的平衡因子为0，说明插入之前parent的平衡因子为正负1，插入后被调整成0，此时满足AVL树的性质，插入成功
如果parent的平衡因子为正负1，说明插入前parent的平衡因子一定为0，插入后被更新成正负1，此时以parent为根的树的高度增加，需要继续向上更新
如果parent的平衡因子为正负2，则parent的平衡因子违反平衡树的性质，需要对其进行旋转处理

bool insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (cur->_kv.first < parent->_kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//更新平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}
			
			// 更新后检测双亲的平衡因子
			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				// 插入前双亲的平衡因子是0，插入后双亲的平衡因为为1 或者 -1 ，说明以双亲为根的二叉树的高度增加了一层，因此需要继续向上调整
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				// 双亲的平衡因子为正负2，违反了AVL树的平衡性，需要对以pParent为根的树进行旋转处理
				//…………
			}
			
		}

		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

调整一共分为四种情况，分别为右单旋、左单旋、右左单旋，左右单旋，我们分别来看。

3.1 新节点插入较高左子树的左侧—左左：右单旋

在这里插入图片描述

上图在插入前，AVL树是平衡的，新节点插入到10的左子树(注意：此处不是左孩子)中，10左子树增加了一层，导致以20为根的二叉树不平衡，要让20平衡，只能将20左子树的高度减少一层，右子树增加一层，即将左子树往上提，这样20转下来，因为20比10大，只能将其放在10的右子树，而如果10有右子树，右子树根的值一定大于10，小于20，只能将其放在20的左子树，旋转完成后，更新节点的平衡因子即可。在旋转过程中，有以下几种情况需要考虑：

10节点的右孩子可能存在，也可能不存在
20可能是根节点，也可能是子树
如果是根节点，旋转完成后，要更新根节点
如果是子树，可能是某个节点的左子树，也可能是右子树

a、b、c分别代表着各种情况，高度为0（也就是为空），高度为1，（为一个节点），高度为2（见图，可以为图中的任意一种），高度为3……等等。
在这里插入图片描述
此处是画出了一个抽象图来讲解，可以映射为各种各样的情况。注意：我们是每插入一个节点就会进行平衡，因此a、b、c一定也为AVL树。
旋转方式：我们将平衡因子为正负2的节点命名为parent，它的左子树命名为subL，subL的右子树命名为subLR，旋转时只需要调整这个几个节点就可以了。
在这里插入图片描述

旋转就是以平衡因子为正负2的节点为基础进行的。将subLR链接到parent的左，再将parent链接到subL的右。

void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		parent->_bf = subL->_bf = 0;
	}
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

但是subLR有可能为空，也就是当a、b、c高度为0时，subLR就会出现为空的情况，因此在使用时需要判断一下。
在这里插入图片描述
但是要注意：我们使用的是三叉链，在进行链接时是需要进行相互链接的，尤其是需要注意parent，如果它不是根节点的话，说明parent的上面还有节点，因此在链接时不能把此处的链接给忘记了。总结一共存在三处链接：第一处是subLR链接到parent的左，第二处链接是将parent链接到subL的右，第三处链接是将subL链接到parent的父亲节点。
旋转完成后还需要调整平衡因子，根据我们画出的图可以看出，在这种调整情况下，最后的平衡因子都变成了0。
在这里插入图片描述

3.2 新节点插入较高右子树的右侧—右右：左单旋

左单旋与右单旋相差无几，仅仅只是调换了一下方向：
在这里插入图片描述
具体情况与右单旋一模一样，在此处我就不进行详细讲解了。

void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		Node* ppNode = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;
		
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

		parent->_bf = subR->_bf = 0;
	}

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

3.3 新节点插入较高左子树的右侧—左右：先左单旋再右单旋

在这里插入图片描述

在这种情况下，我们发现对节点20无论是左单旋还是右单旋都无法减少平衡因子，因此就出现了双旋的情况，我们先对节点10进行左单旋。
在这里插入图片描述

将其变成了只有左边高，这样就转化成了右单旋的问题。
在这里插入图片描述

再对节点20进行右单旋，如此下来我们就发现它们的平衡因子减小了。
在这里插入图片描述

左右双旋我们可以直接复用前面的代码就可以了，但是需要注意平衡因子的调节，新插入节点的位置可能是subLR，也可能是subLR的左，也可能是subLR的右，插入位置不同，平衡因子的调节就不同，大家可以自行画图来观察。

void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(subL);
		RotateR(parent);

		if (bf == 0)
		{
			parent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = subLR->_bf = 0;
		}
		else if(bf = -1)
		{
			parent->_bf = 1;
			subLR->_bf = subL->_bf = 0;
		}
		else
		{
			assert(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

3.4 新节点插入较高右子树的左侧—右左：先右单旋再左单旋

具体的过程与左右双旋情况一致，我这里找了一份图，大家对左右双旋理解透彻了相信对于右左双旋也不在话下，我就偷个懒不做详细解释了。
在这里插入图片描述
这里的平衡因子的调节同样与插入位置有关，可以多画几种情况来观察。

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);

		if (bf == 0)
		{
			parent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if(bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = parent->_bf = 0;
		}
		else
		{
			assert(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

总结：
假如以parent为根的子树不平衡，即parent的平衡因子为2或者-2，分以下情况考虑

parent的平衡因子为2，说明parent的右子树高，设parent的右子树的根为subR

当subR的平衡因子为1时，执行左单旋
当subR的平衡因子为-1时，执行右左双旋

parent的平衡因子为-2，说明parent的左子树高，设parent的左子树的根为subL

当subL的平衡因子为-1是，执行右单旋
当subL的平衡因子为1时，执行左右双旋

旋转完成后，原parent为根的子树个高度降低，已经平衡，不需要再向上更新。

4. AVL树的验证

AVL树是在二叉搜索树的基础上加入了平衡性的限制，因此要验证AVL树，可以分两步：

验证其为二叉搜索树

如果中序遍历可得到一个有序的序列，就说明为二叉搜索树

验证其为平衡树

每个节点子树高度差的绝对值不超过1(注意节点中如果没有平衡因子)
节点的平衡因子是否计算正确

4.1 验证其为二叉搜索树

使用中序进行遍历即可。

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

	_InOrder(root->_left);
	cout << root->_kv.first << " ";
	_InOrder(root->_right);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

4.2 验证其为平衡树

因此还需要写一个计算高度的函数来辅助检查，相信有了前面二叉树的学习，这部分对大家构不成威胁。

int _Hight(Node* _root)
{
	if (_root == nullptr)
		return 0;

	int LeftHight = _Hight(_root->_left);
	int RightHight = _Hight(_root->_right);

	return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
}
bool _IsBalance(Node* _root)
{
	if (_root == nullptr)
		return true;

	int LeftHight = _Hight(_root->_left);
	int RightHight = _Hight(_root->_right);
	if (RightHight - LeftHight != _root->_bf)
	{
		cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
		return false;
	}

	return abs(LeftHight - RightHight) < 2
		&& _IsBalance(_root->_left)
		&& _IsBalance(_root->_right);
}

bool IsBalance()
{
	return _IsBalance(_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

5. AVL树的删除

因为AVL树也是二叉搜索树，可按照二叉搜索树的方式将节点删除，然后再更新平衡因子，只不错与删除不同的时，删除节点后的平衡因子更新，最差情况下一直要调整到根节点的位置。
删除的情况更多也更为复杂，具体实现大家们可参考《算法导论》或《数据结构-用面向对象方法与C++描述》殷人昆版。

6. AVL树的性能

AVL树是一棵绝对平衡的二叉搜索树，其要求每个节点的左右子树高度差的绝对值都不超过1，这样可以保证查询时高效的时间复杂度，即 $log_2 (N)$ 。但是如果要对AVL树做一些结构修改的操作，性能非常低下，比如：插入时要维护其绝对平衡，旋转的次数比较多，更差的是在删除时，有可能一直要让旋转持续到根的位置。因此：如果需要一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修改，就不太适合。

7. 代码实现

7.1 AVL.h

#pragma once
#include<iostream>
#include<vector>
#include<assert.h>
using namespace std;

template<class K,class V>
struct AVLTreeNode
{
	AVLTreeNode<K, V>* _left;
	AVLTreeNode<K, V>* _right;
	AVLTreeNode<K, V>* _parent;
	pair<K, V> _kv;
	int _bf;

	AVLTreeNode(const pair<K,V>& kv)
		:_left(nullptr)
		,_right(nullptr)
		,_parent(nullptr)
		,_kv(kv)
		,_bf(0)
	{}
};

template<class K,class V>
class AVLTree
{
	typedef AVLTreeNode<K, V> Node;
public:
	bool insert(const pair<K,V>& kv)
	{
		if (_root == nullptr)
		{
			_root = new Node(kv);
			return true;
		}

		Node* parent = nullptr;
		Node* cur = _root;

		while (cur)
		{
			if (kv.first > cur->_kv.first)
			{
				parent = cur;
				cur = cur->_right;
			}
			else if(kv.first < cur->_kv.first)
			{
				parent = cur;
				cur = cur->_left;
			}
			else
			{
				return false;
			}
		}

		cur = new Node(kv);
		if (cur->_kv.first < parent->_kv.first)
		{
			parent->_left = cur;
			cur->_parent = parent;
		}
		else
		{
			parent->_right = cur;
			cur->_parent = parent;
		}

		//平衡因子
		while (parent)
		{
			if (cur == parent->_left)
			{
				parent->_bf--;
			}
			else
			{
				parent->_bf++;
			}

			if (parent->_bf == 0)
			{
				break;
			}
			else if (parent->_bf == 1 || parent->_bf == -1)
			{
				cur = parent;
				parent = parent->_parent;
			}
			else if (parent->_bf == 2 || parent->_bf == -2)
			{
				//旋转
				if (parent->_bf == -2 && cur->_bf == -1)
				{
					RotateR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == 1)
				{
					RotateL(parent);
				}
				else if (parent->_bf == -2 && cur->_bf == 1)
				{
					RotateLR(parent);
				}
				else if (parent->_bf == 2 && cur->_bf == -1)
				{
					RotateRL(parent);
				}
				// 1、旋转让这颗子树平衡了
				// 2、旋转降低了这颗子树的高度，恢复到跟插入前一样的高度，所以对上一层没有影响，不用继续更新
				break;
			}
			else
			{
				assert(false);
			}
		}

		return true;
	}

	void RotateL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		Node* ppNode = parent->_parent;

		parent->_right = subRL;
		if (subRL)
			subRL->_parent = parent;

		subR->_left = parent;
		parent->_parent = subR;
		
		if (parent == _root)
		{
			_root = subR;
			subR->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subR;
			}
			else
			{
				ppNode->_right = subR;
			}
			subR->_parent = ppNode;
		}

		parent->_bf = subR->_bf = 0;
	}

	void RotateR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		Node* ppNode = parent->_parent;

		parent->_left = subLR;
		if (subLR)
			subLR->_parent = parent;

		subL->_right = parent;
		parent->_parent = subL;

		if (parent == _root)
		{
			_root = subL;
			subL->_parent = nullptr;
		}
		else
		{
			if (ppNode->_left == parent)
			{
				ppNode->_left = subL;
			}
			else
			{
				ppNode->_right = subL;
			}
			subL->_parent = ppNode;
		}
		parent->_bf = subL->_bf = 0;
	}

	void RotateRL(Node* parent)
	{
		Node* subR = parent->_right;
		Node* subRL = subR->_left;

		int bf = subRL->_bf;

		RotateR(subR);
		RotateL(parent);

		if (bf == 0)
		{
			parent->_bf = subR->_bf = subRL->_bf = 0;
		}
		else if(bf == 1)
		{
			parent->_bf = -1;
			subR->_bf = subRL->_bf = 0;
		}
		else if (bf == -1)
		{
			subR->_bf = 1;
			subRL->_bf = parent->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	void RotateLR(Node* parent)
	{
		Node* subL = parent->_left;
		Node* subLR = subL->_right;
		int bf = subLR->_bf;

		RotateL(subL);
		RotateR(parent);

		if (bf == 0)
		{
			parent->_bf = subL->_bf = subLR->_bf = 0;
		}
		else if (bf == 1)
		{
			subL->_bf = -1;
			parent->_bf = subLR->_bf = 0;
		}
		else if(bf = -1)
		{
			parent->_bf = 1;
			subLR->_bf = subL->_bf = 0;
		}
		else
		{
			assert(false);
		}
	}

	int _Hight(Node* _root)
	{
		if (_root == nullptr)
			return 0;

		int LeftHight = _Hight(_root->_left);
		int RightHight = _Hight(_root->_right);

		return LeftHight > RightHight ? LeftHight + 1 : RightHight + 1;
	}
	bool _IsBalance(Node* _root)
	{
		if (_root == nullptr)
			return true;

		int LeftHight = _Hight(_root->_left);
		int RightHight = _Hight(_root->_right);
		if (RightHight - LeftHight != _root->_bf)
		{
			cout << _root->_kv.first << "平衡因子异常:" << _root->_bf<< endl;
			return false;
		}

		return abs(LeftHight - RightHight) < 2
			&& _IsBalance(_root->_left)
			&& _IsBalance(_root->_right);
	}

	bool IsBalance()
	{
		return _IsBalance(_root);
	}

	void InOrder()
	{
		_InOrder(_root);
		cout << endl;
	}

private:
	void _InOrder(Node* root)
	{
		if (root == nullptr)
			return;

		_InOrder(root->_left);
		cout << root->_kv.first << " ";
		_InOrder(root->_right);
	}

	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
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

7.2 Test.cpp

#define _CRT_SECURE_NO_WARNINGS 1
#include"AVL.h"

void Test1()
{
	int a[] = { 16, 3, 7, 11, 9, 26, 18, 14, 15 };
	AVLTree<int, int> t;
	for (auto e : a)
	{
		t.insert(make_pair(e, e));
	}

	t.InOrder();
	cout << t.IsBalance() << endl;
}


void Test2()
{
	const int N = 100;
	vector<int> v;
	v.reserve(N);
	srand(time(0));

	for (int i = 0; i < N; i++)
	{
		v.push_back(rand());
	}

	AVLTree<int, int> t;
	for (auto e : v)
	{
		t.insert(make_pair(e, e));
		cout << "insert:" << e << "->" << t.IsBalance() << endl;
	}

	cout << t.IsBalance() << endl;
}

int main()
{
	//Test1();
	Test2();
	return 0;
}
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

8. 总结

AVL树最主要的是如何进行旋转，此部分比较难以理解，大家可以通过多画图来反复进行学习。希望大家都能有所收获。
如果大家发现有什么错误的地方，可以私信或者评论区指出喔。我会继续深入学习C++，希望能与大家共同进步，那么本期就到此结束，让我们下期再见！！觉得不错可以点个赞以示鼓励！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/208907