Zengtudor/noi_outline
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Zengtudor 2024-10-23 21:42:28 +08:00
parent 09aeffd2e0
commit 17a4f69f93
1 changed files with 432 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

435
senior/数据结构.md
View File

@ -1,19 +1,25 @@
# 线性结构
## 双端栈
双端栈（**Deque Stack** 或 **Double-ended Stack**）是一种允许在两端进行操作的栈数据结构。通常的栈只能在一端进行操作（称为**栈顶**），即**后进先出**（LIFO, Last In First Out），但双端栈允许在栈的**两端**都可以执行进栈和出栈操作。
>注意，双端栈和双端队列在C++中都可以用std::deque来实现，只有使用上的区别
> 注意，双端栈和双端队列在C++中都可以用std::deque来实现，只有使用上的区别
### 双端栈的特点
1. **两端操作**：双端栈可以在栈的**两端**进行进栈（push）和出栈（pop），即可以从栈的前端或后端插入和删除元素。
2. **灵活性**：与单端栈相比，双端栈提供了更大的灵活性，因为可以根据需要选择从哪一端操作数据。
### 操作
假设双端栈具有两个端点：
- **左端（front）**
- **右端（back）**
主要操作包括：
- **`push_front()`**：在左端插入元素。
- **`push_back()`**：在右端插入元素。
- **`pop_front()`**：从左端弹出元素。
@ -22,10 +28,13 @@
- **`back()`**：访问右端的元素。
### 实现
双端栈通常是通过**双端队列（deque，double-ended queue）**实现的。C++ 中的标准库容器 `std::deque` 就是一个可以在两端高效进行插入和删除操作的数据结构，非常适合用来实现双端栈。
### 应用
双端栈适合用于一些需要在两端频繁操作的场景，比如：
- **滑动窗口问题**：在滑动窗口中，你可能需要同时在窗口的两端添加或移除元素。
- **双向搜索算法**：在某些搜索算法中，可以从两端同时进行搜索。
@ -34,6 +43,7 @@
双端队列（Deque，**Double-Ended Queue**）是一种特殊的队列数据结构，它允许在**两端进行插入和删除**操作。与普通队列（只能从一端入队、另一端出队）不同，双端队列可以从**队首和队尾**进行入队和出队操作，因此具有更大的灵活性。
### 双端队列的主要操作：
1. **从队首插入元素（push_front）**：在队列的前端插入一个元素。
2. **从队尾插入元素（push_back）**：在队列的末尾插入一个元素。
3. **从队首删除元素（pop_front）**：移除队列前端的元素。
@ -42,18 +52,22 @@
6. **访问队尾元素（back）**：查看队列末端的元素。
### 双端队列的分类：
- **输入受限双端队列**：只允许从队首删除元素，但只能从一端插入。
- **输出受限双端队列**：只允许从队尾插入元素，但可以从两端删除元素。
### 双端队列的常见应用：
- **滑动窗口问题**：通过双端队列可以高效地维护一组窗口内的最大或最小值，常用于动态数据流的问题。
- **任务调度**：在一些调度问题中，可以根据任务的优先级从两端进行任务插入和删除。
### 实现方式：
双端队列可以使用**双向链表**或**动态数组**实现。使用双向链表可以在常数时间内从两端插入和删除元素，而使用动态数组在平均情况下可以实现较高的访问效率，但插入和删除操作的效率可能会有所下降，尤其是在需要调整数组大小的时候。
### C++中的双端队列：
C++ 标准库中提供了`deque`容器，它支持双端队列的所有基本操作。例如：
C++ 标准库中提供了 `deque`容器，它支持双端队列的所有基本操作。例如：
```cpp
#include <deque>
@ -223,6 +237,7 @@ public:
```
### 代码解释
- **push_front** 和 **push_back** 分别用于在队首和队尾插入新元素。
- **pop_front** 和 **pop_back** 分别用于从队首和队尾删除元素。
- **getFront** 和 **getBack** 用于访问队首和队尾元素。
@ -262,6 +277,7 @@ int main() {
Front: 10
Back: 10
```
在 C++ 标准库中，`deque`（双端队列）既支持**双端插入和删除**，又可以进行**随机访问**，这与其底层实现方式有关。C++ 的 `deque` 并不是直接用链表实现的，而是通过一种特殊的**分段连续存储**（segmented array）来实现，这使得它可以兼具高效的双端插入删除和随机访问功能。
### `deque` 的底层实现原理
@ -269,13 +285,16 @@ Back: 10
`deque` 的底层通常是一个类似**动态数组的块表结构**，由一组**连续的小块**（chunk 或者 block）组成。每一个小块大小固定，而这些小块之间不需要在内存中是连续的。为了管理这些小块，`deque` 会使用一个指针数组（类似索引表），每个指针指向一个块。这种设计使得 `deque` 既能像链表一样支持高效的双端操作，也能像数组一样支持随机访问。
#### 具体结构：
1. **块表（map）**：`deque` 使用一个指针数组来管理多个小块（chunk/block）。每个指针指向一个内存块，每个内存块保存一定数量的元素。
2. **小块（block）**：每个小块内存大小固定，`deque` 元素分布在不同的小块中，但不同的小块在物理内存中不一定连续。
3. **分段存储**：当你从队首或队尾插入元素时，`deque` 会动态调整块表和小块的数量，不需要像数组那样整体移动数据。
#### 关键点：
- **插入和删除**：从队首和队尾插入删除元素时，`deque` 只需在块表的头部或尾部插入新块，或者移除块表的头尾块。因此，插入删除的开销是常数时间（O(1)），和链表类似。
- **随机访问**：尽管不同小块的内存位置不连续，但由于使用了块表和固定大小的小块，随机访问时，`deque` 通过两步操作来计算元素位置：
- **首先确定元素在块表中的位置**：通过除法 `index / block_size`，确定该元素属于哪个块。
- **再定位块内偏移**：通过取模 `index % block_size`，确定该元素在该块内的偏移量。
@ -284,24 +303,29 @@ Back: 10
### `deque` 和 `vector` 的对比
- **`vector`**：`vector` 是一个连续的动态数组，所有元素存储在一块连续的内存区域中。它提供了高效的随机访问（O(1)），但是插入和删除操作（尤其是队首操作）在最坏情况下需要移动大量元素，开销较大。
- **`deque`**：`deque` 是一种分段的存储方式，不需要保证整个数据在内存中的连续性。这使得它可以同时支持高效的双端插入删除（O(1)），并且还能在 O(1) 时间内随机访问元素。
### 结论
C++ 中的 `deque` 之所以可以支持随机访问，是因为它的底层采用了**分段数组**的存储方式，而不是链表。虽然 `deque` 的内存布局是分散的，但通过使用块表和小块，`deque` 可以在常数时间内定位任意元素的位置，从而实现与数组类似的随机访问性能。
因此，`deque` 是一种非常灵活的数据结构，既可以支持高效的随机访问，又能高效地从两端插入和删除元素。
## 单调队列
单调队列（Monotonic Queue）是一种特别的数据结构，常用于解决一些具有滑动窗口性质的问题。在处理滑动窗口最大值、最小值或者其他具有区间性质的优化问题时，单调队列能够有效地减少时间复杂度，使一些暴力解法从 \(O(n^2)\) 优化为 \(O(n)\) 或 \(O(n \log n)\)。
### 单调队列的作用
单调队列的主要作用是：
1. **在滑动窗口中维护最大值或最小值**：单调队列可以在常数时间内得到滑动窗口的最值。通过维护一个递增或递减的队列，在每次窗口滑动时，可以快速移除不符合要求的元素，并保持队列的单调性。
单调队列的主要作用是：
1. **在滑动窗口中维护最大值或最小值**：单调队列可以在常数时间内得到滑动窗口的最值。通过维护一个递增或递减的队列，在每次窗口滑动时，可以快速移除不符合要求的元素，并保持队列的单调性。
2. **优化动态区间问题**：当我们需要动态地在某个区间内找最大/最小值时，单调队列可以在 \(O(n)\) 的时间复杂度内处理问题，而不需要每次重新遍历区间。
### 基本原理
单调队列之所以高效，关键在于保持队列中的元素是有序的。根据需求，可以维护递增或递减队列：
- **递增队列**：队列中的元素从头到尾是递增的，这样可以在队列头部得到最小值。
- **递减队列**：队列中的元素从头到尾是递减的，这样可以在队列头部得到最大值。
@ -312,6 +336,7 @@ C++ 中的 `deque` 之所以可以支持随机访问，是因为它的底层采
接下来，我们以经典的“滑动窗口最大值”问题为例，给出单调队列的 C++ 实现。
#### 题目描述
给定一个大小为 \(n\) 的数组，和一个大小为 \(k\) 的滑动窗口。窗口从数组的左端移动到右端，每次只向右移动一位，求每个窗口中的最大值。
#### C++ 实现代码
@ -364,21 +389,418 @@ int main() {
```
#### 代码解释
1. **deque**：我们使用双端队列 `dq` 来存储数组元素的下标，确保队列中的元素始终是从大到小排列的。这样队列头部的元素永远是当前窗口的最大值。
2. **删除无效元素**：如果队列中的元素已经不在当前滑动窗口的范围内（即下标小于 \(i - k + 1\)），我们将其从队列头部移除。
3. **保持队列单调性**：在将当前元素插入队列之前，移除所有队列中比当前元素小的元素，因为它们不可能再成为未来窗口的最大值。
4. **记录结果**：一旦窗口大小达到 \(k\)，我们将队列头部的元素（即最大值）加入结果数组。
### 时间复杂度
该算法的时间复杂度为 \(O(n)\)，因为每个元素最多被插入和移除队列一次。
## 优先队列
优先队列（Priority Queue）是一种特殊的队列数据结构，其中每个元素都有一个优先级。在优先队列中，**出队操作会优先处理优先级最高的元素**，而不是像普通队列那样遵循“先进先出”（FIFO）的原则。
### 特性
1. **插入元素**（Enqueue）：可以将元素加入队列，通常是 O(log n) 时间复杂度。
2. **取出最大/最小元素**（Dequeue）：每次从队列中取出优先级最高的元素，通常是 O(log n) 时间复杂度。
3. **查看最大/最小元素**：可以在 O(1) 时间内查看当前优先级最高的元素。
优先队列常用于需要频繁处理最高优先级任务的场景，比如操作系统的进程调度、图算法中的最短路径问题（如 Dijkstra 算法）。
---
### C++ 中的实现
C++ 标准库提供了一个名为 `std::priority_queue` 的容器，可以直接用来实现优先队列。这个容器底层实现通常是**堆**（默认是最大堆），即每次访问的是最大元素。
#### 1. **默认最大堆实现**
```cpp
#include <iostream>
#include <queue>
#include <vector>
int main() {
// 创建一个最大堆的优先队列
std::priority_queue<int> pq;
// 插入元素
pq.push(10);
pq.push(20);
pq.push(15);
// 输出并移除优先级最高的元素
std::cout << "优先级最高的元素: " << pq.top() << std::endl; // 输出 20
pq.pop();
std::cout << "第二高优先级的元素: " << pq.top() << std::endl; // 输出 15
return 0;
}
```
#### 2. **最小堆的实现**
默认情况下，`std::priority_queue` 是最大堆，要实现最小堆，可以通过**自定义比较函数**来实现。可以利用 `std::greater` 或使用 lambda 表达式。
```cpp
#include <iostream>
#include <queue>
#include <vector>
int main() {
// 创建一个最小堆的优先队列
std::priority_queue<int, std::vector<int>, std::greater<int>> pq;
// 插入元素
pq.push(10);
pq.push(20);
pq.push(15);
// 输出并移除优先级最高的元素（最小堆，输出最小值）
std::cout << "优先级最高的元素: " << pq.top() << std::endl; // 输出 10
pq.pop();
std::cout << "第二高优先级的元素: " << pq.top() << std::endl; // 输出 15
return 0;
}
```
#### 3. **自定义优先级的对象**
如果队列中存放的是自定义对象，则需要为该对象实现比较函数。例如，假设有一个任务结构体，优先级根据任务的优先级数值决定：
```cpp
#include <iostream>
#include <queue>
#include <vector>
struct Task {
int id;
int priority;
// 自定义比较运算符，使得 priority 小的优先处理
bool operator<(const Task& other) const {
return priority < other.priority;
}
};
int main() {
std::priority_queue<Task> pq;
// 插入任务
pq.push({1, 5});
pq.push({2, 3});
pq.push({3, 10});
// 输出并移除优先级最高的任务
std::cout << "优先级最高的任务 ID: " << pq.top().id << std::endl; // 输出 3 (priority 10)
return 0;
}
```
这里定义了 `operator<` 来决定优先级高低。默认情况下，`std::priority_queue` 会将优先级最高的任务（`priority` 最大）排在队首。
### 底层实现
`std::priority_queue` 底层使用的是**堆**（heap），常见实现是**二叉堆**。堆是一种二叉树的完全树结构，其中最大堆的父节点总是大于等于其子节点，最小堆的父节点总是小于等于其子节点。堆的性质使得插入和删除操作可以在 O(log n) 时间复杂度内完成。
---
### 自己实现一个优先队列
这里有一个讲的不错的[b站视频](https://www.bilibili.com/video/BV1AF411G7cA/)
<iframe src="//player.bilibili.com/player.html?isOutside=true&aid=297973330&bvid=BV1AF411G7cA&cid=570109806&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true"></iframe>
如果不使用标准库，可以手动实现优先队列，最常见的方法是基于堆。以下是一个简单的基于数组的二叉堆实现的优先队列（最大堆）：
```cpp
#include <iostream>
#include <vector>
#include <stdexcept>
class MaxHeap {
private:
std::vector<int> heap; // 使用 vector 动态数组存储堆元素
// 上浮操作，用于在插入新元素后调整堆的结构
void siftUp(int idx) {
// 当元素不是根节点时，继续调整
while (idx > 0) {
int parent = (idx - 1) / 2; // 计算父节点的索引
// 如果父节点的值已经大于等于当前元素，堆结构正确，结束调整
if (heap[parent] >= heap[idx]) break;
// 否则，交换父节点和当前节点的值
std::swap(heap[parent], heap[idx]);
// 更新当前节点的索引为父节点的索引，继续调整
idx = parent;
}
}
// 下沉操作，用于在删除堆顶元素后调整堆的结构
void siftDown(int idx) {
int n = heap.size(); // 获取堆的大小
// 当当前节点有左子节点时，继续调整（因为左子节点一定存在）
while (2 * idx + 1 < n) {
int left = 2 * idx + 1; // 左子节点的索引
int right = 2 * idx + 2; // 右子节点的索引
int largest = idx; // 假设当前节点是最大的
// 如果左子节点存在并且比当前节点大，更新 largest 为左子节点
if (left < n && heap[left] > heap[largest]) largest = left;
// 如果右子节点存在并且比当前最大节点大，更新 largest 为右子节点
if (right < n && heap[right] > heap[largest]) largest = right;
// 如果 largest 没有改变，说明堆已经调整完毕，退出循环
if (largest == idx) break;
// 否则，交换当前节点和最大子节点的值
std::swap(heap[idx], heap[largest]);
// 更新当前节点的索引为最大子节点的索引，继续调整
idx = largest;
}
}
public:
// 插入一个新元素
void push(int value) {
heap.push_back(value); // 将新元素添加到堆的末尾
siftUp(heap.size() - 1); // 调整堆以保持最大堆性质
}
// 移除堆顶元素（最大值）
void pop() {
if (heap.empty()) throw std::runtime_error("Heap is empty"); // 异常处理，堆为空时抛出错误
heap[0] = heap.back(); // 用最后一个元素替换堆顶
heap.pop_back(); // 删除最后一个元素
if (!heap.empty()) siftDown(0); // 调整堆以保持最大堆性质
}
// 获取堆顶元素（最大值），但不删除
int top() const {
if (heap.empty()) throw std::runtime_error("Heap is empty"); // 异常处理，堆为空时抛出错误
return heap[0]; // 返回堆顶元素
}
// 判断堆是否为空
bool empty() const {
return heap.empty(); // 堆为空返回 true
}
};
int main() {
MaxHeap pq; // 创建一个最大堆对象
// 插入元素到堆中
pq.push(10);
pq.push(20);
pq.push(15);
// 输出堆顶元素（最大值）
std::cout << "最大值: " << pq.top() << std::endl; // 输出 20
pq.pop(); // 移除堆顶元素
std::cout << "第二大值: " << pq.top() << std::endl; // 输出 15
return 0;
}
```
### 代码讲解：
1. **`siftUp()` 和 `siftDown()`**：这两个函数是核心的调整堆结构的操作。`siftUp` 在插入新元素后执行，上浮新元素以保持最大堆结构。`siftDown` 在移除堆顶元素后执行，下沉新的堆顶以保持最大堆结构。
2. **插入操作**：
- 当调用 `push()` 函数时，将新元素添加到堆的末尾，并调用 `siftUp()` 函数调整堆的结构，确保最大堆的性质得到维护。
3. **删除操作**：
- 当调用 `pop()` 函数时，删除堆顶元素（最大值）。为了保持堆的连续性，使用最后一个元素替代堆顶，然后调用 `siftDown()` 来恢复最大堆性质。
4. **`top()` 函数**：返回当前堆中的最大元素，但不删除它。如果堆为空，则抛出异常。
5. **`empty()` 函数**：用于检查堆是否为空。
### 示例输出：
```text
最大值: 20
第二大值: 15
```
## ST表
> [OI Wiki链接](https://oi-wiki.org/ds/sparse-table/)
ST表（Sparse Table）是一种用于解决静态区间查询问题的数据结构，通常用于查询不可变数组中的区间最值（最小值、最大值、最大公约数等）。它的构建时间复杂度为 \(O(n \log n)\)，查询时间复杂度为 \(O(1)\)，非常适合处理多次查询的场景。ST表的原理基于“倍增法”，通过预处理使得每次查询时可以通过少量预处理信息快速得出结果。
### 原理
ST表的核心思想是将原数组分块，并记录每个块中的区间最值。具体来说，给定一个数组 `arr`，ST表预处理的是所有长度为 \(2^j\) 的区间的最值，其中 \(j\) 表示区间的大小为 \(2^j\)。
#### 数据结构
ST表用一个二维数组 `st[i][j]` 表示：
- \(st[i][j]\) 表示从位置 \(i\) 开始，长度为 \(2^j\) 的区间中的最值，即区间 `[i, i + 2^j - 1]` 中的最小值（或最大值、其他运算）。
#### 预处理
预处理的过程如下：
1. 初始化：长度为 \(2^0 = 1\) 的区间的最值就是数组本身。因此，\[
st[i][0] = arr[i] \quad \text{对于每个} \ i \in [0, n-1]。
\]
2. 填充其他长度的区间：
对于 \(j \geq 1\)，区间 `[i, i + 2^j - 1]` 可以通过合并两个长度为 \(2^{j-1}\) 的区间得到：\[
st[i][j] = \min(st[i][j-1], st[i + 2^{j-1}][j-1])。
\]
其中，`min` 操作可以替换为其他操作（如 `max` 或 `gcd`），根据具体需求调整。
#### 查询
对于任意区间 `[L, R]`，我们可以通过分解成两个重叠区间的方式来计算区间最值：
1. 找到满足 \(2^j \leq (R - L + 1)\) 的最大 \(j\)，这个 \(j\) 可以通过查找预处理的 `log` 数组得到（常用二进制计算）。
2. 使用两个长度为 \(2^j\) 的区间覆盖 `[L, R]`：\[
\min(st[L][j], st[R - 2^j + 1][j])
\]
因为两个区间 `[L, L + 2^j - 1]` 和 `[R - 2^j + 1, R]` 会完全覆盖区间 `[L, R]`。
### C++ 实现
以下是 ST 表求区间最小值的 C++ 实现：
下面是为这段 ST 表代码添加的详细注释：
```cpp
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
// ST表类，支持区间最小值查询
class SparseTable {
vector<vector<int>> st; // 用于存储不同区间长度的最小值
vector<int> log; // 用于快速查找 log2 值
int n; // 数组长度
public:
// 构造函数，传入数组并进行预处理
SparseTable(const vector<int>& arr) {
n = arr.size(); // 获取输入数组的大小
int maxLog = log2(n) + 1; // 最大区间长度所需的 log 值，最多到 log2(n)
st.assign(n, vector<int>(maxLog)); // 分配 st 表存储空间，n 行，每行 maxLog 列
log.assign(n + 1, 0); // 初始化 log 数组，存储 log2 的值，0 到 n 共 n+1 个位置
// 初始化 log 数组
// log[i] 表示 log2(i)，从 2 开始进行预处理
for (int i = 2; i <= n; ++i)
log[i] = log[i / 2] + 1;
// 初始化 st 表中的长度为 1 的区间 (即 st[i][0])，这些区间的最小值就是数组本身
for (int i = 0; i < n; ++i)
st[i][0] = arr[i];
// 预处理区间长度为 2^j 的最小值，动态规划填充 st 表
for (int j = 1; j < maxLog; ++j) { // 枚举区间长度 2^j
for (int i = 0; i + (1 << j) <= n; ++i) { // 枚举起点 i，保证 i + 2^j 不越界
// 合并两个长度为 2^(j-1) 的区间，得到长度为 2^j 的区间最小值
st[i][j] = min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
}
}
}
// 查询区间 [L, R] 的最小值
int query(int L, int R) {
// 根据区间长度 R - L + 1 找到最大的 j 使得 2^j <= R - L + 1
int j = log[R - L + 1];
// 返回两个部分的最小值，分别为 [L, L + 2^j - 1] 和 [R - 2^j + 1, R]
return min(st[L][j], st[R - (1 << j) + 1][j]);
}
};
int main() {
// 输入数组
vector<int> arr = {1, 3, 2, 7, 9, 11, 3, 5, 8, 10};
// 创建 ST 表，并传入数组进行预处理
SparseTable st(arr);
// 查询区间 [3, 7] 的最小值
cout << "Minimum in range [3, 7]: " << st.query(3, 7) << endl; // 输出 3
// 查询区间 [1, 4] 的最小值
cout << "Minimum in range [1, 4]: " << st.query(1, 4) << endl; // 输出 2
return 0;
}
```
### 详细注释讲解：
1. **数据结构：**
- `st` 是一个二维数组，存储每个区间的最小值。`st[i][j]` 存储的是从位置 `i` 开始，长度为 \(2^j\) 的区间的最小值。
- `log` 是一个辅助数组，用于存储每个数的对数值，便于快速确定区间大小。
2. **预处理：**
- `log` 数组用来预处理快速计算 \( \log_2 \) 值，避免在查询时重复计算对数。
- `st` 表的初始化从长度为 \(2^0 = 1\) 的区间开始，其值就是数组的原始元素，然后通过倍增法构建更长的区间。
3. **查询：**
- 查询区间 `[L, R]` 时，找到最大的 \( j \) 使得 \(2^j \leq (R - L + 1)\)，并使用两个长度为 \(2^j\) 的区间覆盖原始区间 `[L, R]`。
- 两个区间分别为 `[L, L + 2^j - 1]` 和 `[R - 2^j + 1, R]`，查询这两个子区间的最小值。
4. **主要操作：**
- `log[i / 2] + 1` 用来快速得到当前区间的对数值，确保动态规划的填充和查询过程中的高效计算。
- `min(st[i][j - 1], st[i + (1 << (j - 1))][j - 1])` 使用两个较小的区间合并得到更大的区间最值。
5. **时间复杂度：**
- **预处理**：\(O(n \log n)\)，遍历每个长度的区间进行最小值计算。
- **查询**：\(O(1)\)，每次查询只需要比较两个最小值即可。
# 集合与森林
## 并查集
当然可以！下面是带有详细注释的 C++ 并查集代码，并说明 `rank` 的作用。
```cpp
#include <vector>
using namespace std;
class UnionFind {
public:
// 构造函数，初始化并查集
UnionFind(int size) {
parent.resize(size); // 动态数组存储每个节点的父节点
rank.resize(size, 1); // 动态数组存储每个节点的秩（树的高度）
// 初始化每个节点的父节点为自己
for (int i = 0; i < size; i++) {
parent[i] = i;
}
}
// 查找操作，查找节点p的根节点，同时进行路径压缩
int find(int p) {
if (parent[p] != p) {
parent[p] = find(parent[p]); // 路径压缩
}
return parent[p]; // 返回根节点
}
// 合并操作，将节点p和节点q所在的集合合并
void unionSets(int p, int q) {
int rootP = find(p); // 找到p的根节点
int rootQ = find(q); // 找到q的根节点
if (rootP != rootQ) { // 如果两个节点不在同一集合
// 按秩合并
if (rank[rootP] > rank[rootQ]) {
parent[rootQ] = rootP; // 将小树合并到大树下
} else if (rank[rootP] < rank[rootQ]) {
parent[rootP] = rootQ; // 将小树合并到大树下
} else {
parent[rootQ] = rootP; // 如果秩相同，任意合并
rank[rootP]++; // 提高合并后的树的秩
}
}
}
private:
vector<int> parent; // 存储每个节点的父节点
vector<int> rank; // 存储每个节点的秩（树的高度）
};
```
### `rank` 的作用：
- **树的高度**：`rank` 数组用于记录每个集合的树的高度（或深度）。通过保持较小的树总是连接到较大的树，减少了树的高度，从而提高了查找操作的效率。
- **避免不必要的深度**：如果不使用 `rank`，在多次合并中可能导致某棵树的高度迅速增加，使得查找操作的时间复杂度增加到 O(n)。
## 树的孩子兄弟表示法
# 特殊树
@ -394,6 +816,7 @@ int main() {
## 平衡树(AVL, treap, splay)
# 常见图
## 稀疏图
## 偶图（二分图）
@ -413,5 +836,3 @@ int main() {
## 字符串哈希函数构造
## 哈希冲突的常用处理方法