noi_outline/senior/数据结构.md

# 线性结构
## 双端栈
双端栈（**Deque Stack** 或 **Double-ended Stack**）是一种允许在两端进行操作的栈数据结构。通常的栈只能在一端进行操作（称为**栈顶**），即**后进先出**（LIFO, Last In First Out），但双端栈允许在栈的**两端**都可以执行进栈和出栈操作。

>注意，双端栈和双端队列在C++中都可以用std::deque来实现，只有使用上的区别

### 双端栈的特点
1. **两端操作**：双端栈可以在栈的**两端**进行进栈（push）和出栈（pop），即可以从栈的前端或后端插入和删除元素。
2. **灵活性**：与单端栈相比，双端栈提供了更大的灵活性，因为可以根据需要选择从哪一端操作数据。

### 操作
假设双端栈具有两个端点：
- **左端（front）**
- **右端（back）**

主要操作包括：
- **`push_front()`**：在左端插入元素。
- **`push_back()`**：在右端插入元素。
- **`pop_front()`**：从左端弹出元素。
- **`pop_back()`**：从右端弹出元素。
- **`front()`**：访问左端的元素。
- **`back()`**：访问右端的元素。

### 实现
双端栈通常是通过**双端队列（deque，double-ended queue）**实现的。C++ 中的标准库容器 `std::deque` 就是一个可以在两端高效进行插入和删除操作的数据结构，非常适合用来实现双端栈。

### 应用
双端栈适合用于一些需要在两端频繁操作的场景，比如：
- **滑动窗口问题**：在滑动窗口中，你可能需要同时在窗口的两端添加或移除元素。
- **双向搜索算法**：在某些搜索算法中，可以从两端同时进行搜索。

## 双端队列

双端队列（Deque，**Double-Ended Queue**）是一种特殊的队列数据结构，它允许在**两端进行插入和删除**操作。与普通队列（只能从一端入队、另一端出队）不同，双端队列可以从**队首和队尾**进行入队和出队操作，因此具有更大的灵活性。

### 双端队列的主要操作：
1. **从队首插入元素（push_front）**：在队列的前端插入一个元素。
2. **从队尾插入元素（push_back）**：在队列的末尾插入一个元素。
3. **从队首删除元素（pop_front）**：移除队列前端的元素。
4. **从队尾删除元素（pop_back）**：移除队列末尾的元素。
5. **访问队首元素（front）**：查看队列前端的元素。
6. **访问队尾元素（back）**：查看队列末端的元素。

### 双端队列的分类：
- **输入受限双端队列**：只允许从队首删除元素，但只能从一端插入。
- **输出受限双端队列**：只允许从队尾插入元素，但可以从两端删除元素。

### 双端队列的常见应用：
- **滑动窗口问题**：通过双端队列可以高效地维护一组窗口内的最大或最小值，常用于动态数据流的问题。
- **任务调度**：在一些调度问题中，可以根据任务的优先级从两端进行任务插入和删除。

### 实现方式：
双端队列可以使用**双向链表**或**动态数组**实现。使用双向链表可以在常数时间内从两端插入和删除元素，而使用动态数组在平均情况下可以实现较高的访问效率，但插入和删除操作的效率可能会有所下降，尤其是在需要调整数组大小的时候。

### C++中的双端队列：
C++ 标准库中提供了`deque`容器，它支持双端队列的所有基本操作。例如：

```cpp
#include <deque>
#include <iostream>

int main() {
    std::deque<int> dq;
    
    dq.push_back(1);   // 在队尾插入1
    dq.push_front(2);  // 在队首插入2
    
    std::cout << dq.front() << std::endl;  // 输出队首元素（2）
    std::cout << dq.back() << std::endl;   // 输出队尾元素（1）
    
    dq.pop_back();    // 移除队尾元素
    dq.pop_front();   // 移除队首元素
    
    return 0;
}
```

要用指针实现一个双端队列（Deque），通常使用**双向链表**作为底层数据结构。双向链表中的每个节点都包含指向前驱节点和后继节点的指针，这样我们可以在常数时间内从两端进行插入和删除操作。

### 设计思路

1. **节点结构**：双向链表的每个节点需要包含一个数据字段，以及两个指针字段：分别指向前一个节点和后一个节点。
2. **双端队列结构**：需要维护两个指针，分别指向队列的头节点（front）和尾节点（rear）。还需要跟踪队列的大小。

### 操作逻辑

- **插入操作**：插入时需要更新相应端的指针，同时要处理队列为空时的特殊情况。
- **删除操作**：从队列的两端删除元素后，更新指针，处理删除后队列为空的情况。
- **访问操作**：队首和队尾的元素可以直接通过指针访问。

### 双向链表节点的定义

```cpp
struct Node {
    int data;
    Node* prev;  // 指向前一个节点
    Node* next;  // 指向后一个节点
    Node(int val) : data(val), prev(nullptr), next(nullptr) {}
};
```

### 双端队列类的定义

```cpp
class Deque {
private:
    Node* front;  // 队首指针
    Node* rear;   // 队尾指针
    int size;     // 当前队列中的元素个数

public:
    Deque() : front(nullptr), rear(nullptr), size(0) {}

    // 检查队列是否为空
    bool isEmpty() {
        return size == 0;
    }

    // 返回队列的大小
    int getSize() {
        return size;
    }

    // 在队首插入元素
    void push_front(int val) {
        Node* newNode = new Node(val);
        if (isEmpty()) {
            front = rear = newNode;  // 如果队列为空，队首和队尾都指向新节点
        } else {
            newNode->next = front;   // 新节点的next指向当前的队首
            front->prev = newNode;   // 当前队首的prev指向新节点
            front = newNode;         // 更新队首指针
        }
        size++;
    }

    // 在队尾插入元素
    void push_back(int val) {
        Node* newNode = new Node(val);
        if (isEmpty()) {
            front = rear = newNode;  // 如果队列为空，队首和队尾都指向新节点
        } else {
            newNode->prev = rear;    // 新节点的prev指向当前的队尾
            rear->next = newNode;    // 当前队尾的next指向新节点
            rear = newNode;          // 更新队尾指针
        }
        size++;
    }

    // 从队首删除元素
    void pop_front() {
        if (isEmpty()) {
            std::cout << "Deque is empty, cannot pop from front!" << std::endl;
            return;
        }
        Node* temp = front;
        front = front->next;         // 更新队首指针
        if (front != nullptr) {
            front->prev = nullptr;   // 队首前驱指针置空
        } else {
            rear = nullptr;          // 如果删除后队列为空，更新队尾
        }
        delete temp;                 // 释放节点内存
        size--;
    }

    // 从队尾删除元素
    void pop_back() {
        if (isEmpty()) {
            std::cout << "Deque is empty, cannot pop from back!" << std::endl;
            return;
        }
        Node* temp = rear;
        rear = rear->prev;           // 更新队尾指针
        if (rear != nullptr) {
            rear->next = nullptr;    // 队尾后继指针置空
        } else {
            front = nullptr;         // 如果删除后队列为空，更新队首
        }
        delete temp;                 // 释放节点内存
        size--;
    }

    // 获取队首元素
    int getFront() {
        if (isEmpty()) {
            std::cout << "Deque is empty, no front element!" << std::endl;
            return -1;
        }
        return front->data;
    }

    // 获取队尾元素
    int getBack() {
        if (isEmpty()) {
            std::cout << "Deque is empty, no back element!" << std::endl;
            return -1;
        }
        return rear->data;
    }

    // 打印双端队列
    void printDeque() {
        if (isEmpty()) {
            std::cout << "Deque is empty!" << std::endl;
            return;
        }
        Node* current = front;
        while (current != nullptr) {
            std::cout << current->data << " ";
            current = current->next;
        }
        std::cout << std::endl;
    }

    // 析构函数，释放所有节点
    ~Deque() {
        while (!isEmpty()) {
            pop_front();
        }
    }
};
```

### 代码解释
- **push_front** 和 **push_back** 分别用于在队首和队尾插入新元素。
- **pop_front** 和 **pop_back** 分别用于从队首和队尾删除元素。
- **getFront** 和 **getBack** 用于访问队首和队尾元素。
- **printDeque** 打印队列中的所有元素。
- 析构函数负责在对象销毁时释放所有节点，防止内存泄漏。

### 示例

```cpp
int main() {
    Deque dq;
    dq.push_back(10);  // 队尾插入10
    dq.push_front(20); // 队首插入20
    dq.push_back(30);  // 队尾插入30

    dq.printDeque();   // 输出: 20 10 30

    dq.pop_front();    // 队首删除
    dq.printDeque();   // 输出: 10 30

    dq.pop_back();     // 队尾删除
    dq.printDeque();   // 输出: 10

    std::cout << "Front: " << dq.getFront() << std::endl;  // 输出队首元素: 10
    std::cout << "Back: " << dq.getBack() << std::endl;    // 输出队尾元素: 10

    return 0;
}
```

### 运行结果

```
20 10 30
10 30
10
Front: 10
Back: 10
```
在 C++ 标准库中，`deque`（双端队列）既支持**双端插入和删除**，又可以进行**随机访问**，这与其底层实现方式有关。C++ 的 `deque` 并不是直接用链表实现的，而是通过一种特殊的**分段连续存储**（segmented array）来实现，这使得它可以兼具高效的双端插入删除和随机访问功能。

### `deque` 的底层实现原理

`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`，确定该元素在该块内的偏移量。
  
  这两步操作的时间复杂度都是 O(1)，因此 `deque` 可以像数组一样提供 O(1) 的随机访问。

### `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. **在滑动窗口中维护最大值或最小值**：单调队列可以在常数时间内得到滑动窗口的最值。通过维护一个递增或递减的队列，在每次窗口滑动时，可以快速移除不符合要求的元素，并保持队列的单调性。
   
2. **优化动态区间问题**：当我们需要动态地在某个区间内找最大/最小值时，单调队列可以在 \(O(n)\) 的时间复杂度内处理问题，而不需要每次重新遍历区间。

### 基本原理
单调队列之所以高效，关键在于保持队列中的元素是有序的。根据需求，可以维护递增或递减队列：
- **递增队列**：队列中的元素从头到尾是递增的，这样可以在队列头部得到最小值。
- **递减队列**：队列中的元素从头到尾是递减的，这样可以在队列头部得到最大值。

每当滑动窗口移动时，我们会将新的元素插入队列，同时确保队列的单调性。队列中的元素可能会失效（比如已经不在滑动窗口的范围内），这些元素需要被及时移除。

### C++ 实现滑动窗口最大值问题

接下来，我们以经典的“滑动窗口最大值”问题为例，给出单调队列的 C++ 实现。

#### 题目描述
给定一个大小为 \(n\) 的数组，和一个大小为 \(k\) 的滑动窗口。窗口从数组的左端移动到右端，每次只向右移动一位，求每个窗口中的最大值。

#### C++ 实现代码

```cpp
#include <iostream>
#include <deque>
#include <vector>

using namespace std;

vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> dq;  // 单调队列，存储的是数组元素的下标
    vector<int> result;

    for (int i = 0; i < nums.size(); ++i) {
        // 移除已经不在窗口范围内的元素
        if (!dq.empty() && dq.front() == i - k) {
            dq.pop_front();
        }

        // 移除队列中所有小于当前元素的值，因为它们不可能成为最大值
        while (!dq.empty() && nums[dq.back()] < nums[i]) {
            dq.pop_back();
        }

        // 将当前元素下标添加到队列
        dq.push_back(i);

        // 当窗口长度达到k时，记录当前窗口的最大值
        if (i >= k - 1) {
            result.push_back(nums[dq.front()]);  // 队列头部元素就是当前窗口的最大值
        }
    }

    return result;
}

int main() {
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    vector<int> result = maxSlidingWindow(nums, k);

    for (int max_val : result) {
        cout << max_val << " ";
    }

    return 0;
}
```

#### 代码解释
1. **deque**：我们使用双端队列 `dq` 来存储数组元素的下标，确保队列中的元素始终是从大到小排列的。这样队列头部的元素永远是当前窗口的最大值。
2. **删除无效元素**：如果队列中的元素已经不在当前滑动窗口的范围内（即下标小于 \(i - k + 1\)），我们将其从队列头部移除。
3. **保持队列单调性**：在将当前元素插入队列之前，移除所有队列中比当前元素小的元素，因为它们不可能再成为未来窗口的最大值。
4. **记录结果**：一旦窗口大小达到 \(k\)，我们将队列头部的元素（即最大值）加入结果数组。

### 时间复杂度
该算法的时间复杂度为 \(O(n)\)，因为每个元素最多被插入和移除队列一次。
## 优先队列

## ST表

# 集合与森林

## 并查集

## 树的孩子兄弟表示法

# 特殊树

## 二叉堆，树状数组

## 线段树

## 字典树(Trie树)

## 笛卡尔树

## 平衡树(AVL, treap, splay)

# 常见图
## 稀疏图

## 偶图（二分图）

## 欧拉图

## 有向无环图

## 连通图与强连通图

## 双连通图

# 哈希表

## 数值哈希函数构造

## 字符串哈希函数构造

## 哈希冲突的常用处理方法