-
红黑树的性质与简单实现
红黑树性质
之前的博客中介绍了AVL树的性质与基本实现，红黑树作为另一种树型结构，他又有哪些性质呢？
红黑树作为一种二叉搜索树，与AVL树通过高度差来控制平衡不同，他在每个结点上增加一个存储位表示结点的颜色，可以是Red或Black。 通过对任何一条从根到叶子的路径上各个结点着色方式的限制，红黑树确保没有一条路径会比其他路径长出俩倍，因而是接近平衡的。
因此，红黑树为了控制高度平衡，它具有如下的性质：- 每个结点不是红色就是黑色
- 根节点是黑色的
- 如果一个节点是红色的，则它的两个孩子结点是黑色的
- 对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点
- 每个叶子结点都是黑色的(此处的叶子结点指的是空结点)
红黑树有如上性质就意味着他的结点控制有如下性质：
- 假如红黑树任意一条路径中黑色结点的数量为X，那么该红黑树的高度h则为2X>=h>=X
- 假如红黑树任意一条路径中黑色结点的数量为X，那么该红黑树的结点数量为2^X-1<=N<=2^2X-1
因此与严格平衡的AVL树搜索的时间复杂度相比，AVL树查找的时间复杂度为log2N，而红黑树查找一个树的时间复杂度为2*log2N，但是AVL树控制平衡是需要经常旋转来控制平衡，而红黑树控制平衡所要进行的旋转性能损耗会比AVL树低。
红黑树的简单实现
红黑树的基本构成
红黑树顾名思义每个节点中都存在一个变量来表示该节点的颜色(红色或者黑色)，通过颜色以及红黑树的原则来控制红黑树的平衡，因此红黑树节点可以如下构造：
这里使用枚举来标识红黑树每个节点的颜色，这里默认红黑树每个节点存放的是一个pair类型的变量，红黑树也是通过一个三叉链来实现的。enum Colour { RED, BLACK }; template<class K,class V> struct RBtreeNode { RBtreeNode<K, V>* _left; RBtreeNode<K, V>* _right; RBtreeNode<K, V>* _parent; pair<K, V> _kv; Colour _col; RBtreeNode(const pair<K, V>& kv) :_left(nullptr) , _right(nullptr) , _parent(nullptr) , _kv(kv) , _col(RED) { } };- 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
定义红黑树节点后，可以简单构造出红黑树的基本框架，然后依次实现插入等功能即可。
template<class K,class V> class RBTree { typedef RBtreeNode<K, V> Node; public: RBTree() :_root(nullptr) { } bool Insert(const pair<K, V>& kv); void _InOrder(Node* root); bool IsBalance(); private: Node* _root; };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
红黑树的插入
红黑树插入和AVL树类似，先找到插入位置进行插入，然后再调整平衡，两者之间主要是调整平衡的方式有区别。下面先看一下红黑树的插入过程的代码实现
bool Insert(const pair<K, V>& kv) { if (_root == nullptr)//当插入的节点为根节点的时候 { _root = new Node(kv); _root->_col = BLACK; return true; } Node* parent = nullptr; Node* cur = _root; while (cur) { if (cur->_kv.first < kv.first)//当插入的值比当前节点大时候，往右走 { parent = cur; cur = cur->_right; } else if (cur->_kv.first > kv.first)//当插入的值比当前节点小的时候，往左走 { parent = cur; cur = cur->_left; } else//当出现重复值的时候 { return false; } } cur = new Node(kv); cur->_col = RED;//将插入节点的值设置为红色 这样成本最低 if (parent->_kv.first < kv.first)//当parent节点中的值比kv值小的时候，cur为该节点的右节点 { parent->_right = cur; cur->_parent = parent; } else//当parent节点中的值比kv值大的时候，cur为该节点的左节点 { parent->_left = cur; cur->_parent = parent; } }- 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
通过如上的代码可以实现红黑树新增节点的插入，但是插入后可能会导致红黑树的不平衡或者违反红黑树的基本原则，因此需要对红黑树插入后进行平衡调节。这里平衡调节大致可以分为如下4种情况：
情况1
如下图所示，当parent节点为红，parent的兄弟节点也为红，grandparent节点为黑的时候，插入一个红色的左节点，此时出现了两个连续的红色节点，因此需要进行调整，这里的调整方法是将parent节点和uncle节点都改为黑色，并将grandparent节点改为红色，如果grandparent节点为根节点则改为黑色，否则就继续向上调整，代码实现如下：
while (parent && parent->_col == RED)//当parent存在且为红色时需要进行调整 { Node* grandparent = parent->_parent; if (parent == grandparent->_left) { //变色继续向上调整 Node* uncle = grandparent->_right; //uncle存在且为红 if (uncle && uncle->_col == RED) { parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; } } } _root->_col=BLACK;- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
情况2
当cur为红色节点，parent也为红色节点，grandparent为黑色节点，此时uncle可能不存在也可能为黑色节点，此时如果uncle节点不存在，则cur一定是新插入的节点，因为parent是红色节点，如果cur不是新插入的节点则会不满足每条路径黑色节点个数相同这个原则。
如果uncle节点存在并且为黑的情况下，那么cur节点原来一定是黑色的，现在看到的为红色是因为cur的子树在向上调整的过程中变为红色的。
如果插入节点为左节点，则进行上面的一次右旋即可，如果插入的为右节点，那么则需要先进行左旋转化为前一种情况再进行右旋。
调整实现代码如下：
//uncle不存在或者存在且为黑色 if (cur == parent->_left)//cur是parent的左节点 { RotateR(grandparent); parent->_col = BLACK; grandparent->_col = RED; parent = cur->_parent; } else//如果当前节点是parent的右节点 { RotateL(parent); RotateR(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break;- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
情况3
当parent为grandparent的右节点的时候，和上面两种情况类似，只需要进行相同的处理即可
代码如下：Node* uncle = grandparent->_left; if (uncle && uncle->_col == RED) { //变色向上处理 parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; parent = cur->_parent; } else//uncle不存在或为黑色 { if (cur == parent->_right) { RotateL(grandparent); parent->_col = BLACK; grandparent->_col = RED; } else { RotateR(parent); RotateL(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break; }- 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
旋转
这里的旋转和AVL树中的旋转方式类似，代码如下：
void RotateR(Node* parent)//右单旋 { Node* subL = parent->_left; Node* subLR = subL->_right; parent->_left = subLR; if (subLR) { subLR->_parent = parent; } subL->_right = parent; Node* parentParent = parent->_parent; parent->_parent = subL; if (parent == _root) { _root = subL; _root->_parent = nullptr; } else { if (parentParent->_left == parent) { parentParent->_left = subL; } else { parentParent->_right = subL; } subL->_parent = parentParent; } } void RotateL(Node* parent)//左单旋 { Node* subR = parent->_right; Node* subRL = subR->_left; parent->_right = subRL; if (subRL) { subRL->_parent = parent; } subR->_left = parent; Node* parentParent = parent->_parent; parent->_parent = subR; if (parent == _root) { _root = subR; _root->_parent = nullptr; } else { if (parentParent->_left == parent) { parentParent->_left = subR; } else { parentParent->_right = subR; } subR->_parent = parentParent; } }- 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
总结
红黑树的总体插入代码如下：
bool Insert(const pair<K, V>& kv) { if (_root == nullptr)//当插入的节点为根节点的时候 { _root = new Node(kv); _root->_col = BLACK; return true; } Node* parent = nullptr; Node* cur = _root; while (cur) { if (cur->_kv.first < kv.first)//当插入的值比当前节点大时候，往右走 { parent = cur; cur = cur->_right; } else if (cur->_kv.first > kv.first)//当插入的值比当前节点小的时候，往左走 { parent = cur; cur = cur->_left; } else//当出现重复值的时候 { return false; } } cur = new Node(kv); cur->_col = RED;//将插入节点的值设置为红色 这样成本最低 if (parent->_kv.first < kv.first)//当parent节点中的值比kv值小的时候，cur为该节点的右节点 { parent->_right = cur; cur->_parent = parent; } else//当parent节点中的值比kv值大的时候，cur为该节点的左节点 { parent->_left = cur; cur->_parent = parent; } while (parent && parent->_col == RED)//当parent存在且为红色时需要进行调整 { Node* grandparent = parent->_parent; if (parent == grandparent->_left) { Node* uncle = grandparent->_right; //uncle存在且为红 if (uncle && uncle->_col == RED) { //变色继续向上调整 parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; parent = cur->_parent; } //uncle不存在或者存在且为黑色 else { if (cur == parent->_left)//cur是parent的左节点 { RotateR(grandparent); parent->_col = BLACK; grandparent->_col = RED; } else//如果当前节点是parent的右节点 { RotateL(parent); RotateR(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break; } } else//parent==grandparent->_right { Node* uncle = grandparent->_left; if (uncle && uncle->_col == RED) { //变色向上处理 parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; parent = cur->_parent; } else//uncle不存在或为黑色 { if (cur == parent->_right) { RotateL(grandparent); parent->_col = BLACK; grandparent->_col = RED; } else { RotateR(parent); RotateL(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break; } } } _root->_col = BLACK; 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
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
红黑树的查找
红黑树的查找功能和其他搜索二叉树类似，使用中序遍历即可，代码实现如下：
void InOrder() { return _InOrder(_root); } void _InOrder(Node* root) { if (root == nullptr) { return; } _InOrder(root->_left); cout << root->_kv.first << ":" << root->_kv.second << endl; _InOrder(root->_right); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
红黑树平衡判断
红黑树的平衡判断主要从红黑树的原则入手：第一则是每条路径中黑色节点的个数相同，第二则是不会出现连续的红色节点，第三则是根节点必须为黑色，判断平衡的函数依据以上几个原则来实现：
bool IsBalance()//判断二叉树是否平衡 { if (_root && _root->_col == RED) { cout << "根节点不是黑色" << endl; return false; } int banchmark = 0;//统计某条路径中黑色节点的个数 Node* left = _root;//这里选取最左节点路径 while (left) { if (left->_col == BLACK) { ++banchmark; } left = left->_left; } int blacknum = 0; return _IsBalance(_root, banchmark, blacknum); } bool _IsBalance(Node* root, int banchmark, int blacknum) { if (root == nullptr) { if (banchmark != blacknum) { cout << "存在路径黑色节点不相等" << endl; return false; } return true; } if (root->_col == RED && root->_parent->_col == RED) { cout << "出现连续红色节点" << endl; return false; } if (root->_col == BLACK) { blacknum++; } return _IsBalance(root->_left, banchmark, blacknum) && _IsBalance(root->_right, banchmark, blacknum); }- 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
红黑树的高度计算
这里红黑树的高度计算和正常二叉树的高度计算一样，找出最长路径即可
int Height() { return _Height(_root); } int _Height(Node* root) { if (root == nullptr) { return 0; } int leftHeight = Height(root->_left); int rightHeight = Height(root->_right); return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
红黑树的测试
#include<iostream> using namespace std; enum Colour { RED, BLACK }; template<class K,class V> struct RBtreeNode { RBtreeNode<K, V>* _left; RBtreeNode<K, V>* _right; RBtreeNode<K, V>* _parent; pair<K, V> _kv; Colour _col; RBtreeNode(const pair<K, V>& kv) :_left(nullptr) , _right(nullptr) , _parent(nullptr) , _kv(kv) , _col(RED) { } }; template<class K,class V> class RBTree { typedef RBtreeNode<K, V> Node; public: RBTree() :_root(nullptr) { } bool Insert(const pair<K, V>& kv) { if (_root == nullptr)//当插入的节点为根节点的时候 { _root = new Node(kv); _root->_col = BLACK; return true; } Node* parent = nullptr; Node* cur = _root; while (cur) { if (cur->_kv.first < kv.first)//当插入的值比当前节点大时候，往右走 { parent = cur; cur = cur->_right; } else if (cur->_kv.first > kv.first)//当插入的值比当前节点小的时候，往左走 { parent = cur; cur = cur->_left; } else//当出现重复值的时候 { return false; } } cur = new Node(kv); cur->_col = RED;//将插入节点的值设置为红色 这样成本最低 if (parent->_kv.first < kv.first)//当parent节点中的值比kv值小的时候，cur为该节点的右节点 { parent->_right = cur; cur->_parent = parent; } else//当parent节点中的值比kv值大的时候，cur为该节点的左节点 { parent->_left = cur; cur->_parent = parent; } while (parent && parent->_col == RED)//当parent存在且为红色时需要进行调整 { Node* grandparent = parent->_parent; if (parent == grandparent->_left) { Node* uncle = grandparent->_right; //uncle存在且为红 if (uncle && uncle->_col == RED) { //变色继续向上调整 parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; parent = cur->_parent; } //uncle不存在或者存在且为黑色 else { if (cur == parent->_left)//cur是parent的左节点 { RotateR(grandparent); parent->_col = BLACK; grandparent->_col = RED; } else//如果当前节点是parent的右节点 { RotateL(parent); RotateR(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break; } } else//parent==grandparent->_right { Node* uncle = grandparent->_left; if (uncle && uncle->_col == RED) { //变色向上处理 parent->_col = uncle->_col = BLACK; grandparent->_col = RED; cur = grandparent; parent = cur->_parent; } else//uncle不存在或为黑色 { if (cur == parent->_right) { RotateL(grandparent); parent->_col = BLACK; grandparent->_col = RED; } else { RotateR(parent); RotateL(grandparent); cur->_col = BLACK; grandparent->_col = RED; } break; } } } _root->_col = BLACK; return false; } void InOrder() { return _InOrder(_root); } bool IsBalance()//判断二叉树是否平衡 { if (_root && _root->_col == RED) { cout << "根节点不是黑色" << endl; return false; } int banchmark = 0;//统计某条路径中黑色节点的个数 Node* left = _root;//这里选取最左节点路径 while (left) { if (left->_col == BLACK) { ++banchmark; } left = left->_left; } int blacknum = 0; return _IsBalance(_root, banchmark, blacknum); } int Height() { return _Height(_root); } private: void _InOrder(Node* root) { if (root == nullptr) { return; } _InOrder(root->_left); cout << root->_kv.first << ":" << root->_kv.second << endl; _InOrder(root->_right); } bool _IsBalance(Node* root, int banchmark, int blacknum) { if (root == nullptr) { if (banchmark != blacknum) { cout << "存在路径黑色节点不相等" << endl; return false; } return true; } if (root->_col == RED && root->_parent->_col == RED) { cout << "出现连续红色节点" << endl; return false; } if (root->_col == BLACK) { blacknum++; } return _IsBalance(root->_left, banchmark, blacknum) && _IsBalance(root->_right, banchmark, blacknum); } int _Height(Node* root) { if (root == nullptr) { return 0; } int leftHeight = _Height(root->_left); int rightHeight = _Height(root->_right); return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1; } void RotateR(Node* parent)//右单旋 { Node* subL = parent->_left; Node* subLR = subL->_right; parent->_left = subLR; if (subLR) { subLR->_parent = parent; } subL->_right = parent; Node* parentParent = parent->_parent; parent->_parent = subL; if (parent == _root) { _root = subL; _root->_parent = nullptr; } else { if (parentParent->_left == parent) { parentParent->_left = subL; } else { parentParent->_right = subL; } subL->_parent = parentParent; } } void RotateL(Node* parent) { Node* subR = parent->_right; Node* subRL = subR->_left; parent->_right = subRL; if (subRL) { subRL->_parent = parent; } subR->_left = parent; Node* parentParent = parent->_parent; parent->_parent = subR; if (parent == _root) { _root = subR; _root->_parent = nullptr; } else { if (parentParent->_left == parent) { parentParent->_left = subR; } else { parentParent->_right = subR; } subR->_parent = parentParent; } } 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
- 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
上面是该红黑树简单实现的完整代码，接下来使用插入一段随机的数组来验证该红黑树的构建，测试代码如下：
void TestRBTree() { int arr[] = { 2,15,12,74,64,13,15,10,11,13,12,18 }; RBTree<int, int> Node; for (auto e : arr) { Node.Insert(make_pair(e, e)); } Node.InOrder(); cout << Node.IsBalance() << endl; cout << Node.Height() << endl; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
void TestRBTree() { vector<int> v; //int arr[] = { 2,15,12,74,64,13,15,10,11,13,12,18 }; srand(time(0)); int N = 1000000; for (int i = 0; i < N; i++) { v.push_back(rand()); } RBTree<int, int> Node; for (auto e : v) { Node.Insert(make_pair(e, e)); } //Node.InOrder(); cout << Node.IsBalance() << endl; cout << Node.Height() << endl; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
这里测试1000000个随机数进行插入，生成二叉树，可以看到他只有19层左右 -
相关阅读:
Django: 3. 创建游戏界面
微服务实战系列之Sentinel
i.MX 6ULL 驱动开发 二十二：SPI(SPI子系统+MISC子系统)
JAVA基础 - URI、URL和URN的区别
Netty入门指南之基础介绍
CARLA和LGSVL坐标系差异
【MySQL | 运维篇】06、MySQL 分库分表之 MyCat 分片规则
Diffle-Hellman Key Exchange密钥交换
CSS的选择器(一篇文章齐全)
【真实面试】JAVA22年初的开发面试
- 原文地址：https://blog.csdn.net/h1091068389/article/details/125370463