update

2024-10-23 13:08:58 +08:00 · 2024-10-23 13:08:58 +08:00 · 09aeffd2e0
commit 09aeffd2e0
parent f4fb5a79e0
1 changed files with 417 additions and 0 deletions
--- a/senior/数据结构.md
+++ b/senior/数据结构.md
@ -0,0 +1,417 @@
+# 线性结构
+## 双端栈
+双端栈（**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)
+
+# 常见图
+## 稀疏图
+
+## 偶图（二分图）
+
+## 欧拉图
+
+## 有向无环图
+
+## 连通图与强连通图
+
+## 双连通图
+
+# 哈希表
+
+## 数值哈希函数构造
+
+## 字符串哈希函数构造
+
+## 哈希冲突的常用处理方法
+
+