当前位置：首页 > news >正文

解锁C++数据结构：开启高效编程之旅

news 2025/7/13 7:30:49

一、数据结构基础概念
二、数组（Array）
- 2.1 数组的定义与初始化
- 2.2 数组的特点
- 2.3 数组的应用场景
三、栈（Stack）
- 3.1 栈的基本概念
- 3.2 C++ 中栈的实现
- 3.3 栈的应用场景
四、队列（Queue）
- 4.1 队列的基本概念
- 4.2 C++ 中队列的实现
- 4.3 队列的应用场景
五、链表（Linked List）
- 5.1 链表的基本概念
- 5.2 C++ 中链表的实现
- 5.3 链表的特点与应用场景
六、树（Tree）
- 6.1 树的基本概念
- 6.2 二叉树
- 6.3 C++ 中二叉树的实现
- 6.4 二叉树的扩展结构
七、堆（Heap）
- 7.1 堆的基本概念
- 7.2 C++ 中堆的实现
- 7.3 堆的应用场景
八、哈希映射（Hash Map）
- 8.1 哈希映射的基本概念
- 8.2 C++ 中哈希映射的实现
- 8.3 哈希映射的应用场景
九、总结与展望

一、数据结构基础概念

在计算机编程的世界里，数据结构就像是一座大厦的基石，起着举足轻重的作用。它决定了数据的组织、存储和管理方式，直接影响着程序的性能、效率以及可维护性。可以说，掌握数据结构是成为优秀程序员的必备技能，它为解决各种复杂的编程问题提供了有力的工具和方法。

数据结构，简单来讲，是相互之间存在一种或多种特定关系的数据元素的集合。这些关系定义了数据元素如何相互关联，以及我们如何操作和访问这些数据。数据结构主要包含两方面的内容：逻辑结构和存储结构。

逻辑结构描述的是数据元素之间的逻辑关系，它从抽象的层面定义了数据的组织方式，主要有以下四种类型：

集合结构：数据元素之间除了 “同属一个集合” 的关系外，没有其他特定关系。例如，一个班级里所有学生组成的集合，学生之间没有明显的顺序或层次关系。
线性结构：数据元素之间存在一对一的线性关系。就像排队一样，每个元素都有唯一的前驱（除了第一个元素）和后继（除了最后一个元素）。常见的线性结构有数组、链表、栈和队列等。比如，我们日常使用的购物清单，每一项商品就如同线性结构中的一个元素，按顺序排列。
树形结构：元素之间存在一对多的层次关系，类似一棵倒挂的树。每个节点（除了根节点）都有一个父节点，同时可以有多个子节点。文件系统就是典型的树形结构，文件夹可以包含多个子文件夹和文件。
图形结构：数据元素之间存在多对多的复杂关系，图由节点和连接节点的边组成，边可以有权重等属性。城市交通网络可以看作是一个图形结构，各个城市是节点，城市之间的道路是边。

存储结构则关注数据在计算机内存中的实际存储方式，它是逻辑结构的物理实现，常见的存储结构包括：

顺序存储结构：数据元素在内存中按顺序连续存储，通过数组来实现。这种存储方式的优点是可以快速随机访问元素，比如访问数组中第 n 个元素的时间复杂度为 O (1)。就像书架上按编号摆放的书籍，我们可以快速找到指定编号的书。
链式存储结构：数据元素在内存中不要求连续存储，通过指针将各个节点连接起来，形成链表。链表在插入和删除操作上效率较高，时间复杂度为 O (1)，因为只需修改指针指向即可，无需移动大量元素。但访问元素时需要从头遍历链表，时间复杂度为 O (n)，如同在一条街上挨家挨户找某个门牌号。
索引存储结构：为数据建立索引表，通过索引来快速定位数据元素。数据库中的索引就是这种存储结构的应用，通过索引可以大大提高数据查询的效率。比如字典的目录，通过目录索引可以快速找到对应的字词解释。
散列存储结构：也叫哈希存储，通过哈希函数将数据元素的关键字映射到一个存储位置，实现快速查找。哈希表是典型的散列存储结构，平均情况下查找、插入和删除操作的时间复杂度都接近 O (1) 。例如，根据学生的学号快速查找学生信息，就可以利用哈希表来实现高效查询。

在 C++ 编程中，数据结构有着广泛的应用场景：

容器类库：C++ 标准库提供了丰富的容器类，如 vector（动态数组）、list（双向链表）、stack（栈）、queue（队列）、map（映射，基于红黑树实现）和 unordered_map（无序映射，基于哈希表实现）等。这些容器类是数据结构在 C++ 中的具体实现，它们封装了数据的存储和操作逻辑，大大提高了编程效率。比如，使用 vector 来存储一组整数，可以方便地进行元素的添加、删除和访问操作。
算法实现：许多算法都依赖特定的数据结构来实现。例如，图的遍历算法（深度优先搜索 DFS 和广度优先搜索 BFS）需要使用栈或队列来辅助实现；最短路径算法（如 Dijkstra 算法）通常使用优先队列（堆）来优化性能。在实现这些算法时，选择合适的数据结构可以显著提高算法的效率。
系统开发：在操作系统、数据库管理系统等系统软件的开发中，数据结构更是不可或缺。操作系统中的进程管理、内存管理等模块都需要运用各种数据结构来实现高效的资源管理和调度。数据库管理系统中，数据的存储、索引和查询优化都依赖于复杂的数据结构设计。

二、数组（Array）

2.1 数组的定义与初始化

数组是一种线性数据结构，它由一组相同类型的元素组成，这些元素在内存中连续存储。在 C++ 中，数组的定义方式有多种，以下是一些常见的示例：

一维数组：定义一个包含 5 个整数的数组，可以使用以下方式：

int arr[5]; // 定义一个长度为5的整型数组，此时数组元素未初始化

也可以在定义时进行初始化：

int arr[5] = {1, 2, 3, 4, 5}; // 初始化数组元素

如果初始化时提供的元素数量少于数组大小，剩余的元素将被自动初始化为 0（对于内置类型）：

int arr[5] = {1, 2}; // arr[0]=1, arr[1]=2, arr[2]=0, arr[3]=0, arr[4]=0

还可以省略数组大小，让编译器根据初始化列表自动推断数组大小：

int arr[] = {1, 2, 3, 4, 5}; // 编译器自动推断数组大小为5

二维数组：定义一个 3 行 4 列的二维整型数组，可以这样写：

int matrix[3][4]; // 定义一个3行4列的二维整型数组，元素未初始化

在定义时初始化二维数组：

int matrix[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}
};

也可以简化初始化方式：

int matrix[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

同样，二维数组也可以省略行数（但列数不能省略），让编译器根据初始化列表推断行数：

int matrix[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};

2.2 数组的特点

优点：
- 随机访问速度快：由于数组元素在内存中连续存储，通过索引可以直接计算出元素的内存地址，从而实现快速访问。例如，访问arr[i]的时间复杂度为 O (1)，这使得数组在需要频繁随机访问元素的场景下表现出色。比如在实现一个简单的学生成绩管理系统时，如果用数组存储学生成绩，根据学生的编号（对应数组索引）可以快速获取其成绩。
- 内存利用率高：数组元素紧密排列，没有额外的指针或其他元数据开销（除了数组本身的管理信息），在存储大量相同类型数据时，能有效利用内存空间。
缺点：
- 大小固定：数组一旦创建，其大小就不能动态改变。如果需要存储的数据量可能会变化，使用数组可能会导致内存浪费（分配过大）或不足（分配过小）。例如，在处理一个可能不断增长的用户列表时，若使用固定大小的数组，当用户数量超过数组容量时就需要重新分配更大的数组并复制数据，这是非常低效的操作。
- 插入和删除操作时间复杂度高：在数组中间插入或删除元素时，需要移动后续元素以保持连续性，时间复杂度为 O (n)。例如，在一个按学号顺序存储学生信息的数组中，要插入一个新学生的信息到中间位置，就需要将插入位置之后的所有学生信息向后移动一位。

2.3 数组的应用场景

数学计算：在科学计算和数学应用中，数组常用于存储矩阵、向量等数据结构。例如，在进行矩阵乘法运算时，使用二维数组来表示矩阵，通过对数组元素的操作来实现矩阵乘法的逻辑。在图形学中，也经常使用数组来存储顶点坐标、颜色等信息。
存储固定大小数据：当需要存储固定数量且类型相同的数据时，数组是很好的选择。比如，一个班级有固定数量的学生，要存储每个学生的年龄，可以使用数组来实现。
缓存数据：在一些需要临时存储数据的场景中，数组可以作为缓存使用。例如，在一个文件读取程序中，可以使用数组来缓存从文件中读取的数据块，提高读取效率。

三、栈（Stack）

3.1 栈的基本概念

栈是一种特殊的线性表，它遵循后进先出（Last In First Out，LIFO）的原则。想象一下一叠盘子，最后放上去的盘子会最先被拿走，而最先放的盘子则在最下面，最后才会被取到，这就是栈的工作方式。

在栈中，有两个重要的端点：栈顶（Top）和栈底（Bottom）。所有的插入（入栈，Push）和删除（出栈，Pop）操作都只能在栈顶进行。当我们往栈里添加元素时，新元素会被放置在栈顶，成为栈顶元素；而当我们从栈中移除元素时，总是移除栈顶的那个元素。例如，在一个函数调用的过程中，函数的参数、局部变量等信息会被依次压入栈中，函数执行完毕后，这些信息会按照后进先出的顺序从栈中弹出。

栈的基本操作包括：

入栈（Push）：将一个元素添加到栈顶。例如，在一个整数栈中，执行push(5)操作后，5 就被添加到栈顶。
出栈（Pop）：移除栈顶元素。若栈中当前元素为 5、3、1（栈顶为 5），执行pop()操作后，5 被移除，栈顶变为 3。
获取栈顶元素（Top/Peek）：返回栈顶元素，但不删除它。比如，栈顶元素为 5，执行top()操作后，返回 5，栈的状态不变。
判断栈是否为空（IsEmpty）：检查栈中是否有元素，若栈为空返回true，否则返回false。
获取栈的大小（Size）：返回栈中元素的个数。例如，栈中有 3 个元素，执行size()操作后，返回 3。

3.2 C++ 中栈的实现

在 C++ 中，我们可以使用标准库中的<stack>来方便地实现栈。<stack>是一个容器适配器，它默认基于std::deque（双端队列）实现，但也可以指定其他容器作为底层实现，如std::vector（向量）或std::list（链表）。以下是使用std::stack的示例代码：

#include <iostream>
#include <stack>int main() {std::stack<int> myStack; // 创建一个整型栈// 入栈操作myStack.push(10);myStack.push(20);myStack.push(30);// 获取栈顶元素std::cout << "Top element: " << myStack.top() << std::endl; // 输出: 30// 出栈操作myStack.pop();std::cout << "Top element after pop: " << myStack.top() << std::endl; // 输出: 20// 判断栈是否为空std::cout << "Is stack empty? " << (myStack.empty()? "Yes" : "No") << std::endl; // 输出: No// 获取栈的大小std::cout << "Stack size: " << myStack.size() << std::endl; // 输出: 2return 0;
}

除了使用标准库，我们也可以自己实现栈。下面是一个基于数组的简单栈实现：

#include <iostream>
#include <stdexcept>class Stack {
private:int* arr;int top;int capacity;public:Stack(int size = 100) : capacity(size), top(-1) {arr = new int[capacity];}~Stack() {delete[] arr;}void push(int x) {if (top == capacity - 1) {throw std::overflow_error("Stack Overflow");}arr[++top] = x;}int pop() {if (isEmpty()) {throw std::underflow_error("Stack Underflow");}return arr[top--];}int peek() const {if (isEmpty()) {throw std::underflow_error("Stack is empty");}return arr[top];}bool isEmpty() const {return top == -1;}
};

这个自定义栈类包含了基本的栈操作：构造函数用于初始化栈，push方法用于入栈，pop方法用于出栈，peek方法用于获取栈顶元素，isEmpty方法用于判断栈是否为空。在实现过程中，我们使用一个数组来存储栈中的元素，top变量表示栈顶的位置。

3.3 栈的应用场景

栈在计算机科学和编程中有广泛的应用，以下是一些常见的场景：

函数调用与递归：当一个函数被调用时，系统会将该函数的局部变量、参数、返回地址等信息压入栈中，形成一个栈帧（Stack Frame）。当函数执行完毕后，这些信息会从栈中弹出，程序返回到调用该函数的位置继续执行。递归函数的实现也依赖于栈，每一次递归调用都会在栈中创建一个新的栈帧，保存当前调用的上下文信息，直到递归结束，栈帧依次弹出。例如，计算阶乘的递归函数：

int factorial(int n) {if (n == 0 || n == 1) {return 1;}return n * factorial(n - 1);
}

在这个函数中，每次递归调用factorial(n - 1)时，当前的n值和返回地址等信息都会被压入栈中，当递归返回时，这些信息从栈中弹出，用于计算最终的结果。

表达式求值：在计算数学表达式时，栈可以用来处理运算符的优先级和括号。例如，将中缀表达式（如3 + 5 * (2 - 8)）转换为后缀表达式（也叫逆波兰表达式，如3 5 2 8 - * +），然后利用栈来计算后缀表达式的值。具体步骤如下：
- 初始化一个空栈和一个空的后缀表达式列表。
- 从左到右扫描中缀表达式：
  - 如果是数字，直接添加到后缀表达式列表。
  - 如果是左括号，压入栈中。
  - 如果是右括号，不断弹出栈顶元素并添加到后缀表达式列表，直到遇到左括号（左括号弹出但不添加到后缀表达式）。
  - 如果是运算符，当栈为空或栈顶为左括号，直接压入栈；否则，比较当前运算符与栈顶运算符的优先级，若当前运算符优先级低或等于栈顶运算符，弹出栈顶运算符并添加到后缀表达式列表，直到栈顶运算符优先级低于当前运算符或栈顶为左括号，然后将当前运算符压入栈。
- 扫描结束后，将栈中剩余的运算符依次弹出并添加到后缀表达式列表。
- 计算后缀表达式的值：初始化一个空栈，从左到右扫描后缀表达式，遇到数字压入栈，遇到运算符，从栈中弹出两个操作数进行运算，将结果压入栈，扫描结束后，栈顶元素即为表达式的值。
括号匹配：在编译器、文本编辑器等工具中，需要检查代码中的括号是否匹配。可以使用栈来实现这个功能，当遇到左括号（如(、[、{）时，将其压入栈中；当遇到右括号（如)、]、}）时，弹出栈顶元素并检查是否匹配，如果不匹配则说明括号不匹配。例如，对于字符串{[()()]}，扫描过程中，{、[、(依次压入栈，遇到)时，(弹出匹配，遇到)时，(弹出匹配，遇到]时，[弹出匹配，遇到}时，{弹出匹配，最终栈为空，说明括号匹配；而对于字符串{[(])}，遇到]时，栈顶为(，不匹配，说明括号不匹配。
深度优先搜索（DFS）：在图或树的遍历中，深度优先搜索算法可以使用栈来实现。从起始节点开始，将其压入栈中，然后循环取出栈顶节点，访问该节点，如果该节点有未访问的邻接节点，将其中一个邻接节点压入栈中，标记为已访问；如果没有未访问的邻接节点，则弹出栈顶节点，直到栈为空。例如，在一个简单的图中，从节点 A 出发进行 DFS，A 压入栈，取出 A 访问，A 的邻接节点 B、C，将 B 压入栈，取出 B 访问，B 的邻接节点 D，将 D 压入栈，取出 D 访问，D 没有未访问邻接节点，弹出 D，B 没有未访问邻接节点，弹出 B，再将 C 压入栈，取出 C 访问，以此类推，直到遍历完所有可达节点。

四、队列（Queue）

4.1 队列的基本概念

队列是一种特殊的线性表，它遵循先进先出（First In First Out，FIFO）的原则。就像我们日常生活中排队买票一样，先到的人排在前面，先接受服务，后到的人排在后面，依次等待。在队列中，允许插入的一端称为队尾（Rear），允许删除的一端称为队头（Front）。

队列的基本操作包括：

入队（Enqueue/Push）：将一个元素添加到队尾。例如，在一个整数队列中，执行enqueue(5)操作后，5 就被添加到队尾。
出队（Dequeue/Pop）：移除队头元素。若队列中当前元素为 1、3、5（队头为 1），执行dequeue()操作后，1 被移除，队头变为 3。
获取队首元素（Front/Peek）：返回队头元素，但不删除它。比如，队头元素为 1，执行front()操作后，返回 1，队列的状态不变。
判断队列是否为空（IsEmpty）：检查队列中是否有元素，若队列为空返回true，否则返回false。
获取队列的大小（Size）：返回队列中元素的个数。例如，队列中有 3 个元素，执行size()操作后，返回 3。

4.2 C++ 中队列的实现

在 C++ 中，我们可以使用标准库中的<queue>来实现队列。<queue>是一个容器适配器，它默认基于std::deque（双端队列）实现，但也可以指定其他容器作为底层实现，如std::list（链表）。以下是使用std::queue的示例代码：

#include <iostream>
#include <queue>int main() {std::queue<int> myQueue; // 创建一个整型队列// 入队操作myQueue.push(10);myQueue.push(20);myQueue.push(30);// 获取队首元素std::cout << "Front element: " << myQueue.front() << std::endl; // 输出: 10// 出队操作myQueue.pop();std::cout << "Front element after pop: " << myQueue.front() << std::endl; // 输出: 20// 判断队列是否为空std::cout << "Is queue empty? " << (myQueue.empty()? "Yes" : "No") << std::endl; // 输出: No// 获取队列的大小std::cout << "Queue size: " << myQueue.size() << std::endl; // 输出: 2return 0;
}

如果想要自定义队列，也可以通过数组或链表来实现。下面是一个基于链表的简单队列实现：

#include <iostream>
#include <stdexcept>// 定义队列节点结构体
template <typename T>
struct QueueNode {T data;QueueNode* next;QueueNode(const T& value) : data(value), next(nullptr) {}
};// 定义队列类
template <typename T>
class Queue {
private:QueueNode<T>* front;QueueNode<T>* rear;public:Queue() : front(nullptr), rear(nullptr) {}~Queue() {while (front != nullptr) {QueueNode<T>* temp = front;front = front->next;delete temp;}}void enqueue(const T& value) {QueueNode<T>* newNode = new QueueNode<T>(value);if (rear == nullptr) {front = rear = newNode;} else {rear->next = newNode;rear = newNode;}}T dequeue() {if (front == nullptr) {throw std::underflow_error("Queue is empty");}QueueNode<T>* temp = front;T value = temp->data;front = front->next;if (front == nullptr) {rear = nullptr;}delete temp;return value;}T peek() const {if (front == nullptr) {throw std::underflow_error("Queue is empty");}return front->data;}bool isEmpty() const {return front == nullptr;}
};

这个自定义队列类使用链表来存储元素，front指针指向队头节点，rear指针指向队尾节点。enqueue方法用于将元素添加到队尾，dequeue方法用于移除队头元素并返回其值，peek方法用于获取队头元素，isEmpty方法用于判断队列是否为空。

4.3 队列的应用场景

队列在计算机科学和编程中有很多应用场景，以下是一些常见的例子：

多线程阻塞队列管理：在多线程编程中，阻塞队列常用于协调线程之间的工作。例如，生产者 - 消费者模型中，生产者线程将任务放入阻塞队列，消费者线程从队列中取出任务进行处理。当队列满时，生产者线程会被阻塞，直到有空间可用；当队列空时，消费者线程会被阻塞，直到有新任务加入。这有助于避免线程竞争和数据不一致的问题，提高程序的并发性能。使用 C++ 标准库中的std::queue结合互斥锁和条件变量可以实现一个简单的阻塞队列：

#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>std::queue<int> taskQueue;
std::mutex queueMutex;
std::condition_variable queueNotEmpty;// 生产者线程函数
void producer() {for (int i = 1; i <= 5; ++i) {std::unique_lock<std::mutex> lock(queueMutex);taskQueue.push(i);std::cout << "Produced: " << i << std::endl;lock.unlock();queueNotEmpty.notify_one();std::this_thread::sleep_for(std::chrono::seconds(1));}
}// 消费者线程函数
void consumer() {while (true) {std::unique_lock<std::mutex> lock(queueMutex);queueNotEmpty.wait(lock, [] { return!taskQueue.empty(); });int task = taskQueue.front();taskQueue.pop();std::cout << "Consumed: " << task << std::endl;lock.unlock();if (task == 5) {break;}}
}int main() {std::thread producerThread(producer);std::thread consumerThread(consumer);producerThread.join();consumerThread.join();return 0;
}

广度优先搜索（BFS）：在图或树的遍历中，广度优先搜索算法使用队列来实现。从起始节点开始，将其加入队列，然后循环取出队列中的节点，访问该节点，并将其未访问的邻接节点加入队列，直到队列为空。这样可以按照层次顺序遍历图或树，找到从起始节点到目标节点的最短路径（如果存在）。例如，在一个简单的图中，从节点 A 出发进行 BFS，A 加入队列，取出 A 访问，将 A 的邻接节点 B、C 加入队列，取出 B 访问，将 B 的邻接节点 D 加入队列，取出 C 访问，取出 D 访问，以此类推，直到遍历完所有可达节点。下面是一个使用队列实现图的广度优先搜索的示例代码：

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_set>// 图的邻接表表示
using AdjList = std::vector<std::vector<int>>;// 广度优先搜索函数
void bfs(const AdjList& graph, int start) {std::unordered_set<int> visited;std::queue<int> q;q.push(start);visited.insert(start);while (!q.empty()) {int current = q.front();q.pop();std::cout << "Visited: " << current << std::endl;for (int neighbor : graph[current]) {if (visited.find(neighbor) == visited.end()) {q.push(neighbor);visited.insert(neighbor);}}}
}int main() {// 示例图的邻接表AdjList graph = {{1, 2},{0, 2, 3},{0, 1, 3},{1, 2}};bfs(graph, 0);return 0;
}

在这个示例中，graph表示图的邻接表，bfs函数使用队列q来实现广度优先搜索，从起始节点start开始遍历图，并标记已访问的节点。

五、链表（Linked List）

5.1 链表的基本概念

链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列节点（Node）组成，这些节点可以在运行时动态生成。

每个节点通常包含两个部分：

数据域（Data Field）：用于存储数据元素本身，例如一个整数、字符串或者其他复杂的数据类型。比如在一个存储学生信息的链表中，数据域可以存放学生的姓名、学号、成绩等信息。
指针域（Pointer Field）：也称为链域，用于存储下一个节点的地址（在 C++ 中表现为指针），通过这个指针，各个节点在逻辑上连接成一条链。例如，节点 A 的指针域指向节点 B，就表示节点 A 的下一个节点是 B。

链表主要有以下几种类型：

单链表（Singly Linked List）：每个节点只包含一个指向下一个节点的指针。链表的第一个节点称为头节点（Head），通过头节点可以访问整个链表；最后一个节点的指针为空（nullptr），表示链表的结束。例如，在一个简单的整数单链表中，节点 1 的指针指向节点 2，节点 2 的指针指向节点 3，以此类推，节点 3 的指针为nullptr 。单链表的结构简单，实现起来较为容易，但只能从前往后单向遍历链表。
双向链表（Doubly Linked List）：每个节点除了有一个指向下一个节点的指针（next）外，还有一个指向前一个节点的指针（prev）。这使得双向链表可以双向遍历，既可以从前往后，也可以从后往前。例如，在双向链表中，节点 B 的next指针指向节点 C，prev指针指向节点 A，这样在遍历链表或者进行插入、删除操作时，可以更灵活地访问前后节点。双向链表在一些需要频繁双向访问节点的场景中非常有用，但由于每个节点需要额外存储一个指针，相比单链表会占用更多的内存空间。
循环链表（Circular Linked List）：分为单向循环链表和双向循环链表。在单向循环链表中，最后一个节点的指针不是指向nullptr，而是指向头节点，形成一个闭环，这样可以从链表中的任意一个节点开始，循环遍历整个链表。例如，在一个单向循环链表中，节点 3 的指针指向头节点 1，当遍历到节点 3 后，通过其指针又可以回到头节点 1 继续遍历。双向循环链表则是在双向链表的基础上，使头节点的prev指针指向最后一个节点，最后一个节点的next指针指向头节点，同样形成一个闭环，支持双向循环遍历。循环链表常用于实现一些需要循环操作的数据结构，如循环队列等。

5.2 C++ 中链表的实现

单链表的实现
在 C++ 中，实现单链表可以定义一个节点结构体，然后通过指针来连接各个节点。以下是一个简单的单链表实现示例，包括节点定义、链表的插入、删除和遍历操作：

#include <iostream>// 定义单链表节点结构体
struct ListNode {int data;ListNode* next;ListNode(int x) : data(x), next(nullptr) {}
};// 定义单链表类
class SinglyLinkedList {
private:ListNode* head;public:SinglyLinkedList() : head(nullptr) {}// 插入节点到链表头部void insertAtHead(int data) {ListNode* newNode = new ListNode(data);newNode->next = head;head = newNode;}// 插入节点到链表尾部void insertAtTail(int data) {ListNode* newNode = new ListNode(data);if (head == nullptr) {head = newNode;return;}ListNode* current = head;while (current->next != nullptr) {current = current->next;}current->next = newNode;}// 删除指定值的节点void deleteNode(int data) {if (head == nullptr) {return;}if (head->data == data) {ListNode* temp = head;head = head->next;delete temp;return;}ListNode* current = head;while (current->next != nullptr && current->next->data != data) {current = current->next;}if (current->next != nullptr) {ListNode* temp = current->next;current->next = current->next->next;delete temp;}}// 遍历链表并输出节点数据void traverse() const {ListNode* current = head;while (current != nullptr) {std::cout << current->data << " ";current = current->next;}std::cout << std::endl;}// 析构函数，释放链表内存~SinglyLinkedList() {while (head != nullptr) {ListNode* temp = head;head = head->next;delete temp;}}
};

双向链表的实现
双向链表的实现比单链表稍微复杂一些，因为每个节点需要维护两个指针。以下是双向链表的实现示例：

#include <iostream>// 定义双向链表节点结构体
struct DoublyListNode {int data;DoublyListNode* prev;DoublyListNode* next;DoublyListNode(int x) : data(x), prev(nullptr), next(nullptr) {}
};// 定义双向链表类
class DoublyLinkedList {
private:DoublyListNode* head;public:DoublyLinkedList() : head(nullptr) {}// 插入节点到链表头部void insertAtHead(int data) {DoublyListNode* newNode = new DoublyListNode(data);if (head != nullptr) {head->prev = newNode;newNode->next = head;}head = newNode;}// 插入节点到链表尾部void insertAtTail(int data) {DoublyListNode* newNode = new DoublyListNode(data);if (head == nullptr) {head = newNode;return;}DoublyListNode* current = head;while (current->next != nullptr) {current = current->next;}current->next = newNode;newNode->prev = current;}// 删除指定值的节点void deleteNode(int data) {if (head == nullptr) {return;}if (head->data == data) {DoublyListNode* temp = head;head = head->next;if (head != nullptr) {head->prev = nullptr;}delete temp;return;}DoublyListNode* current = head;while (current != nullptr && current->data != data) {current = current->next;}if (current != nullptr) {if (current->prev != nullptr) {current->prev->next = current->next;}if (current->next != nullptr) {current->next->prev = current->prev;}delete current;}}// 正向遍历链表并输出节点数据void traverseForward() const {DoublyListNode* current = head;while (current != nullptr) {std::cout << current->data << " ";current = current->next;}std::cout << std::endl;}// 反向遍历链表并输出节点数据void traverseBackward() const {DoublyListNode* current = head;if (current == nullptr) {return;}while (current->next != nullptr) {current = current->next;}while (current != nullptr) {std::cout << current->data << " ";current = current->prev;}std::cout << std::endl;}// 析构函数，释放链表内存~DoublyLinkedList() {while (head != nullptr) {DoublyListNode* temp = head;head = head->next;delete temp;}}
};

5.3 链表的特点与应用场景

链表的优点
- 动态扩展：链表中的节点是在需要时动态分配内存的，不需要预先知道数据的总量，因此可以灵活地适应数据量的变化。比如在一个实时监控系统中，需要不断记录新的数据，使用链表就可以随时添加新节点来存储这些数据，而不用担心内存不足或预先分配过多内存导致浪费。
- 插入删除速度快：在链表中插入或删除节点时，只需修改相关节点的指针，不需要移动大量的数据。在链表中间插入一个新节点，只需找到插入位置的前一个节点，修改其next指针指向新节点，新节点的next指针指向原节点的下一个节点即可，时间复杂度为 O (1)（前提是已知插入位置）。同样，删除节点时也只需修改前后节点的指针，将被删除节点从链表中脱离，然后释放其内存。这使得链表在需要频繁进行插入和删除操作的场景中表现出色，例如在一个联系人管理系统中，经常需要添加新联系人或删除已有的联系人，使用链表可以高效地完成这些操作。
链表的缺点
- 无法随机访问：链表中的节点在内存中不是连续存储的，不能像数组那样通过索引直接访问特定位置的节点。要访问链表中的某个节点，必须从链表的头节点开始，依次遍历每个节点，直到找到目标节点，时间复杂度为 O (n)，其中 n 是链表的长度。例如，在一个包含 100 个节点的链表中，要访问第 50 个节点，需要从头开始遍历前 49 个节点才能找到，这在需要频繁随机访问数据的场景下效率很低。
- 内存碎片化：由于链表节点是动态分配内存的，随着链表的不断插入和删除操作，可能会导致内存碎片化，即内存中出现许多不连续的小块空闲内存。这会降低内存的利用率，并且在申请较大的连续内存块时可能会失败。例如，在一个长时间运行的程序中，频繁地创建和销毁链表节点，可能会使内存变得碎片化，影响程序的性能。
链表的应用场景
- 实现栈和队列：链表可以方便地实现栈和队列这两种数据结构。栈遵循后进先出（LIFO）的原则，队列遵循先进先出（FIFO）的原则，通过在链表的头部或尾部进行插入和删除操作，可以很容易地模拟栈和队列的行为。例如，使用单链表实现栈时，可以将插入和删除操作都在链表的头部进行，每次插入新元素就相当于栈的入栈操作，删除头部元素就相当于栈的出栈操作。使用链表实现队列时，可以在链表的尾部插入元素（入队），在链表的头部删除元素（出队）。
- 实时数据处理：在一些需要实时处理数据的场景中，如实时监控系统、传感器数据采集等，数据是不断产生的，且可能需要频繁地插入和删除数据。链表的动态扩展和快速插入删除特性使其非常适合这类场景。例如，在一个股票交易系统中，需要实时记录股票的价格变化，使用链表可以随时添加新的价格数据节点，并且在需要删除过时数据时也能高效完成。
- 文件系统：在文件系统中，文件的存储位置可能是不连续的，通过链表可以有效地管理文件的存储和访问。每个文件可以看作是链表中的一个节点，文件的元数据（如文件名、文件大小、创建时间等）存储在节点的数据域中，而指针域用于指向下一个文件节点或者文件的下一个存储块。这样可以方便地进行文件的添加、删除和查找操作。例如，当用户创建一个新文件时，在链表中添加一个新节点；当用户删除文件时，从链表中删除对应的节点。

六、树（Tree）

6.1 树的基本概念

树是一种非线性的数据结构，它由一系列节点（Node）和连接这些节点的边（Edge）组成，具有明显的层次结构。树被广泛应用于计算机科学和其他领域，如文件系统、数据库索引、决策树算法等。

在树中，有一个特殊的节点被称为根节点（Root），它是树的起始点，没有父节点。除了根节点外，每个节点都有且仅有一个父节点，通过父节点可以追溯到根节点。节点可以有零个或多个子节点，子节点是与该节点直接相连且处于下一层的节点。例如，在一个公司的组织结构图中，公司的 CEO 可以看作是根节点，各个部门经理是 CEO 的子节点，而部门经理下面的员工则是部门经理的子节点。

树的一些重要概念如下：

节点的度（Degree of a Node）：节点拥有的子树个数，也就是该节点直接相连的子节点数量。比如，一个节点有 3 个子节点，那么它的度就是 3 。在二叉树中，节点的度最大为 2。
叶子节点（Leaf Node）：也称为终端节点，是没有子节点的节点，其度为 0。在文件系统的树形结构中，文件就相当于叶子节点，它们没有子节点。
内部节点（Internal Node）：度大于 0 的节点，即至少有一个子节点的节点。在公司组织结构图中，部门经理就是内部节点，他们有下属员工（子节点）。
兄弟节点（Sibling）：具有相同父节点的节点互为兄弟节点。例如，在一个家庭的族谱树中，同一个父亲的多个子女就是兄弟节点。
路径（Path）：从一个节点到另一个节点所经过的节点序列，路径上的边数称为路径长度。比如从根节点到某个叶子节点的路径，就是从根节点开始，依次经过它的子节点，直到到达该叶子节点所经过的所有节点。
树的度（Degree of a Tree）：树中所有节点的度的最大值，它反映了树中节点的分支情况。如果一棵树中某个节点的度为 5，而其他节点的度都小于 5，那么这棵树的度就是 5。
层次（Level）：从根节点开始定义，根节点为第 1 层，根节点的子节点为第 2 层，依此类推。节点的层次表示了它在树中的深度位置。在一个表示家族辈分的树中，第一代祖先（根节点）是第 1 层，他们的子女是第 2 层，孙辈是第 3 层。
树的深度（Depth）或高度（Height）：树中节点的最大层次，它衡量了树的 “高度” 或 “深度” 。例如，一棵有 5 层节点的树，它的深度就是 5。树的深度可以通过递归计算得到，根节点的深度为 1，子树的深度是其所有子节点深度的最大值加 1。

6.2 二叉树

二叉树是一种特殊的树结构，它的每个节点最多有两个子节点，分别称为左子节点（Left Child）和右子节点（Right Child）。二叉树的子树也分为左子树和右子树，且左右子树的顺序不能颠倒，这使得二叉树具有明确的方向性和有序性。

二叉树具有以下特性：

每个节点最多有两个子节点：这是二叉树最基本的定义，与多叉树（每个节点可以有多个子节点）形成鲜明对比。例如，在一个简单的二叉树中，每个节点要么没有子节点，要么有一个左子节点和一个右子节点，不会出现有三个或更多子节点的情况。
子树有左右之分，次序不能颠倒：即使一个节点只有一棵子树，也必须明确指出它是左子树还是右子树。例如，对于只有一个子树的节点，如果该子树在左边，那它就是左子树；如果在右边，就是右子树，这种顺序的区分在二叉树的各种操作中非常重要。
递归定义：二叉树是递归定义的，即一个二叉树或者为空，或者由一个根节点加上它的左子树和右子树组成，而左子树和右子树又分别是由根节点、左子树和右子树组成的二叉树。这使得二叉树的结构和操作可以通过递归的方式进行描述和实现。
有唯一根节点（非空树）：在二叉树中，除了空树之外，任何一棵二叉树都只有一个根节点，它是整个二叉树的起始点和核心。
具有层次结构：二叉树是一种层次结构的数据结构，从根节点开始，每一层节点都可能有子节点，形成树状结构。通过层次结构，可以方便地对二叉树进行遍历和操作。
节点的度：二叉树中，节点的度是指该节点拥有的子节点数。在二叉树中，每个节点的度最大为 2，即每个节点最多有两个子节点。
叶子节点：二叉树中没有子节点的节点称为叶子节点。叶子节点是二叉树中特殊的节点，它们位于树的末端，没有子树。
树的深度：二叉树的深度（或高度）是指从根节点到最远叶子节点的最长路径上的节点数。空树的深度为 0，只有一个根节点的二叉树深度为 1。

有一些特殊类型的二叉树，它们具有独特的性质和应用：

满二叉树：如果一棵二叉树的所有分支节点都存在左子树和右子树，并且所有叶子节点都在同一层上，那么这棵二叉树被称为满二叉树。满二叉树的特点是节点数达到了同深度二叉树的最大值，其每一层的节点数都是 2 的幂次方（从第 1 层的 1 个节点开始，第 2 层 2 个节点，第 3 层 4 个节点，以此类推）。例如，深度为 3 的满二叉树，总共有 2^3 - 1 = 7 个节点。
完全二叉树：对于深度为 k 的，有 n 个节点的二叉树，当且仅当其每一个节点都与深度为 k 的满二叉树中编号从 1 至 n 的节点一一对应时，这棵树被称为完全二叉树。完全二叉树的叶子节点只可能出现在最后一层或倒数第二层，并且最后一层的叶子节点从左到右连续排列。例如，在一个深度为 4 的完全二叉树中，如果总共有 10 个节点，那么前三层是满二叉树的结构，最后一层的前两个位置有节点，其余位置为空。完全二叉树在存储和操作上有一些特殊的优势，比如可以使用数组来高效地存储，并且在一些算法中（如堆排序）经常被使用。

6.3 C++ 中二叉树的实现

在 C++ 中，实现二叉树通常需要定义二叉树的节点结构，以及实现对二叉树的各种操作，如插入节点、删除节点、遍历二叉树等。下面是一个简单的二叉树节点定义和遍历算法的实现示例：

#include <iostream>// 定义二叉树节点结构体
struct TreeNode {int val;TreeNode* left;TreeNode* right;TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};// 前序遍历：先访问根节点，再递归遍历左子树，最后递归遍历右子树
void preorderTraversal(TreeNode* root) {if (root != nullptr) {std::cout << root->val << " ";preorderTraversal(root->left);preorderTraversal(root->right);}
}// 中序遍历：先递归遍历左子树，再访问根节点，最后递归遍历右子树
void inorderTraversal(TreeNode* root) {if (root != nullptr) {inorderTraversal(root->left);std::cout << root->val << " ";inorderTraversal(root->right);}
}// 后序遍历：先递归遍历左子树，再递归遍历右子树，最后访问根节点
void postorderTraversal(TreeNode* root) {if (root != nullptr) {postorderTraversal(root->left);postorderTraversal(root->right);std::cout << root->val << " ";}
}int main() {// 创建一个简单的二叉树TreeNode* root = new TreeNode(1);root->left = new TreeNode(2);root->right = new TreeNode(3);root->left->left = new TreeNode(4);root->left->right = new TreeNode(5);std::cout << "前序遍历结果: ";preorderTraversal(root);std::cout << std::endl;std::cout << "中序遍历结果: ";inorderTraversal(root);std::cout << std::endl;std::cout << "后序遍历结果: ";postorderTraversal(root);std::cout << std::endl;// 释放二叉树的内存（省略了详细的释放代码，实际应用中需要完整的释放逻辑）return 0;
}

在这个示例中，TreeNode结构体定义了二叉树的节点，每个节点包含一个整数值val，以及指向左子节点和右子节点的指针left和right。preorderTraversal、inorderTraversal和postorderTraversal函数分别实现了二叉树的前序遍历、中序遍历和后序遍历。在main函数中，创建了一个简单的二叉树，并调用这三个遍历函数输出遍历结果。

6.4 二叉树的扩展结构

二叉树有许多扩展结构，它们在不同的场景中发挥着重要作用。

平衡二叉树：也称为 AVL 树，它是一种自平衡的二叉搜索树。平衡二叉树的每个节点的左右子树的高度差的绝对值不超过 1，通过旋转操作（左旋、右旋、左右旋、右左旋）来保持平衡。平衡二叉树保证了在最坏情况下，插入、删除和查找操作的时间复杂度都为 O (log n)，其中 n 是节点数。例如，在一个存储大量数据的字典中，如果使用平衡二叉树来组织数据，就可以快速地进行查找、插入和删除操作。
红黑树：是一种自平衡的二叉搜索树，它通过在节点上添加颜色属性（红色或黑色）来保证树的平衡。红黑树满足以下性质：每个节点或者是红色，或者是黑色；根节点是黑色；每个叶子节点（NIL）是黑色；如果一个节点是红色的，则它的子节点必须是黑色的；从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。红黑树的查找、插入和删除操作的时间复杂度也是 O (log n)，并且在实际应用中，它的性能表现良好，常用于各种编程语言的标准库中，如 C++ 的 STL 中的map和set就是基于红黑树实现的。
B + 树：是一种多路搜索树，它主要用于数据库和文件系统中。B + 树的特点是所有数据都存储在叶子节点，非叶子节点只存储索引信息，用于引导查询。叶子节点之间通过链表相连，这使得 B + 树在范围查询上具有很大的优势。例如，在 MySQL 数据库中，索引结构就使用了 B + 树，它可以高效地进行数据的插入、删除、查找和范围查询操作。B + 树的查询时间复杂度为 O (log n)，并且由于其节点可以存储多个键值对，减少了磁盘 I/O 操作，提高了查询效率。在处理大规模数据时，B + 树能够有效地组织和管理数据，满足数据库系统对高性能和高可靠性的要求。

七、堆（Heap）

7.1 堆的基本概念

堆是一种特殊的数据结构，它是一种完全二叉树，具有以下特性：

大顶堆（Max Heap）：每个父节点的值都大于或等于其子节点的值，即对于堆中的任意节点i，如果它有左子节点2i + 1和右子节点2i + 2（假设数组从 0 开始索引），那么arr[i] >= arr[2i + 1]且arr[i] >= arr[2i + 2] 。这意味着大顶堆的根节点是整个堆中的最大值。例如，在一个大顶堆[9, 5, 7, 2, 4, 6]中，根节点 9 大于它的子节点 5 和 7，节点 5 大于它的子节点 2 和 4，节点 7 大于它的子节点 6。
小顶堆（Min Heap）：每个父节点的值都小于或等于其子节点的值，即arr[i] <= arr[2i + 1]且arr[i] <= arr[2i + 2] 。小顶堆的根节点是整个堆中的最小值。比如，在小顶堆[1, 3, 4, 7, 8, 9]中，根节点 1 小于它的子节点 3 和 4，节点 3 小于它的子节点 7 和 8，节点 4 小于它的子节点 9。

堆通常使用数组来实现，这是因为完全二叉树的性质使得可以通过数组索引来高效地访问和操作节点。对于数组中索引为i的节点，它的父节点索引为(i - 1) / 2（整数除法），左子节点索引为2i + 1，右子节点索引为2i + 2。这种基于数组的存储方式不仅节省内存，而且在进行堆的操作时，如插入、删除和堆化，都能通过简单的算术运算快速定位节点，提高了操作效率。

7.2 C++ 中堆的实现

在 C++ 中，可以使用标准库<algorithm>中的make_heap、push_heap、pop_heap等函数来操作堆。以下是一些示例代码：

#include <iostream>
#include <vector>
#include <algorithm>int main() {std::vector<int> heap;// 插入元素到堆中heap.push_back(3);heap.push_back(1);heap.push_back(4);heap.push_back(1);heap.push_back(5);heap.push_back(9);// 将vector转换为大顶堆std::make_heap(heap.begin(), heap.end());// 输出堆顶元素（最大值）std::cout << "Top element of the heap: " << heap.front() << std::endl;// 插入新元素heap.push_back(2);std::push_heap(heap.begin(), heap.end());std::cout << "Top element after push: " << heap.front() << std::endl;// 删除堆顶元素std::pop_heap(heap.begin(), heap.end());heap.pop_back();std::cout << "Top element after pop: " << heap.front() << std::endl;return 0;
}

如果要自己实现堆，可以定义一个类来管理堆的操作。以下是一个简单的大顶堆实现示例：

#include <iostream>
#include <vector>
#include <stdexcept>class MaxHeap {
private:std::vector<int> heap;// 调整堆以保持大顶堆性质void heapifyDown(int index) {int largest = index; // 初始化根节点为最大元素int left = 2 * index + 1; // 左子节点索引int right = 2 * index + 2; // 右子节点索引// 如果左子节点大于根节点if (left < heap.size() && heap[left] > heap[largest])largest = left;// 如果右子节点大于最大元素if (right < heap.size() && heap[right] > heap[largest])largest = right;// 如果最大元素不是根节点if (largest != index) {std::swap(heap[index], heap[largest]);// 递归地调整受影响的子树heapifyDown(largest);}}public:// 插入元素到堆中void push(int value) {heap.push_back(value);int index = heap.size() - 1;// 调整堆以保持大顶堆性质while (index > 0 && heap[(index - 1) / 2] < heap[index]) {std::swap(heap[(index - 1) / 2], heap[index]);index = (index - 1) / 2;}}// 删除堆顶元素void pop() {if (heap.empty())throw std::underflow_error("Heap is empty");heap[0] = heap.back();heap.pop_back();// 调整堆以保持大顶堆性质heapifyDown(0);}// 获取堆顶元素int top() const {if (heap.empty())throw std::underflow_error("Heap is empty");return heap[0];}// 判断堆是否为空bool empty() const {return heap.empty();}// 获取堆的大小size_t size() const {return heap.size();}
};

7.3 堆的应用场景

堆在计算机科学和编程中有许多重要的应用场景：

优先队列（Priority Queue）：堆是实现优先队列的常用数据结构。在优先队列中，每个元素都有一个优先级，堆的特性使得可以快速访问和处理优先级最高（大顶堆）或最低（小顶堆）的元素。例如，在任务调度系统中，每个任务都有一个优先级，使用优先队列（基于堆实现）可以确保高优先级的任务先被执行。在 C++ 中，标准库<queue>提供了priority_queue容器适配器，它默认使用大顶堆来实现优先队列。以下是一个使用priority_queue的简单示例：

#include <iostream>
#include <queue>int main() {std::priority_queue<int> pq;pq.push(3);pq.push(1);pq.push(4);pq.push(1);pq.push(5);pq.push(9);while (!pq.empty()) {std::cout << pq.top() << " ";pq.pop();}return 0;
}

在这个示例中，priority_queue按照元素的优先级（默认是从大到小）依次输出元素。

堆排序（Heap Sort）：堆排序是一种基于堆的数据结构的排序算法。它的基本思想是先将待排序的数组构建成一个堆（大顶堆或小顶堆），然后不断地将堆顶元素与堆的末尾元素交换，并调整堆以保持堆的性质，直到整个数组有序。堆排序的时间复杂度为 O (n log n)，其中 n 是数组的长度。例如，对于数组[3, 1, 4, 1, 5, 9]，首先构建成大顶堆[9, 5, 4, 1, 1, 3]，然后将堆顶元素 9 与末尾元素 3 交换，得到[3, 5, 4, 1, 1, 9]，接着调整堆，使其再次成为大顶堆[5, 3, 4, 1, 1, 9]，继续交换和调整，最终得到有序数组[1, 1, 3, 4, 5, 9] 。以下是一个简单的堆排序实现：

#include <iostream>
#include <vector>// 调整堆以保持大顶堆性质
void heapify(std::vector<int>& arr, int n, int i) {int largest = i; // 初始化根节点为最大元素int left = 2 * i + 1; // 左子节点索引int right = 2 * i + 2; // 右子节点索引// 如果左子节点大于根节点if (left < n && arr[left] > arr[largest])largest = left;// 如果右子节点大于最大元素if (right < n && arr[right] > arr[largest])largest = right;// 如果最大元素不是根节点if (largest != i) {std::swap(arr[i], arr[largest]);// 递归地调整受影响的子树heapify(arr, n, largest);}
}// 堆排序函数
void heapSort(std::vector<int>& arr) {int n = arr.size();// 构建大顶堆for (int i = n / 2 - 1; i >= 0; --i)heapify(arr, n, i);// 一个一个地提取元素for (int i = n - 1; i > 0; --i) {// 将当前堆顶元素移到数组末尾std::swap(arr[0], arr[i]);// 调用最大堆调整函数，对剩余元素进行调整heapify(arr, i, 0);}
}int main() {std::vector<int> arr = {3, 1, 4, 1, 5, 9};std::cout << "Original array: ";for (int num : arr)std::cout << num << " ";std::cout << std::endl;heapSort(arr);std::cout << "Sorted array: ";for (int num : arr)std::cout << num << " ";std::cout << std::endl;return 0;
}

在这个示例中，heapify函数用于调整堆以保持大顶堆性质，heapSort函数实现了堆排序的整个过程。通过堆排序，我们可以高效地对数组进行排序，尤其适用于处理大规模数据。

八、哈希映射（Hash Map）

8.1 哈希映射的基本概念

哈希映射，也称为散列映射，是一种基于哈希表的数据结构，用于实现键值对（Key-Value Pair）的映射关系。它通过哈希函数（Hash Function）将键映射到哈希表（Hash Table）中的一个位置，从而可以快速地根据键找到对应的值。哈希映射的核心思想是利用哈希函数将键转换为一个唯一的索引值，这个索引值就像一把钥匙，能够直接定位到存储值的位置，大大提高了查找效率。

哈希函数是哈希映射的关键组成部分，它将任意长度的输入（键）转换为固定长度的输出（哈希值）。一个好的哈希函数应具备以下特点：

高效性：计算哈希值的速度要快，以减少时间开销。例如，简单的除留余数法，将键值对中的键对哈希表的大小取模，得到的余数作为哈希值，这种方法计算简单，效率较高。
均匀性：尽可能将不同的键均匀地映射到哈希表的各个位置，减少哈希冲突（Collision）的发生。哈希冲突是指不同的键经过哈希函数计算后得到相同的哈希值。例如，对于哈希函数hash(key) = key % 10，如果有多个键都是 10 的倍数，那么它们的哈希值都会是 0，就会发生哈希冲突。
确定性：相同的键必须产生相同的哈希值，这样才能保证在查找时能够准确地定位到对应的值。例如，对于字符串键 “apple”，无论在何时何地计算其哈希值，都应该得到相同的结果。

8.2 C++ 中哈希映射的实现

在 C++ 中，我们可以使用标准库中的<unordered_map>来实现哈希映射。<unordered_map>是 C++ 11 引入的，它基于哈希表实现，提供了快速的插入、删除和查找操作。以下是一个简单的示例，展示了如何使用<unordered_map>来存储和查找学生的成绩：

#include <iostream>
#include <unordered_map>
#include <string>int main() {// 创建一个unordered_map，键为学生姓名，值为成绩std::unordered_map<std::string, int> studentScores;// 插入键值对studentScores["Alice"] = 95;studentScores["Bob"] = 87;studentScores["Charlie"] = 92;// 查找学生成绩std::string studentName = "Alice";auto it = studentScores.find(studentName);if (it != studentScores.end()) {std::cout << studentName << "'s score is: " << it->second << std::endl;} else {std::cout << studentName << " not found." << std::endl;}return 0;
}

在这个示例中，我们创建了一个std::unordered_map<std::string, int>，其中键是学生的姓名（std::string类型），值是学生的成绩（int类型）。通过studentScores[“Alice”] = 95这样的方式插入键值对，通过studentScores.find(studentName)来查找特定学生的成绩。

当发生哈希冲突时，<unordered_map>默认使用链地址法（Chaining）来处理。链地址法是指在哈希表的每个位置上维护一个链表，当多个键映射到同一个位置时，这些键值对就被插入到对应的链表中。例如，假设有两个学生 “David” 和 “Eve” 的哈希值相同，那么它们的键值对会被插入到哈希表中同一个位置的链表中。在查找时，需要遍历链表来找到目标键值对。

除了链地址法，另一种常见的哈希冲突处理方法是开放地址法（Open Addressing）。开放地址法是指当发生冲突时，通过某种探测策略在哈希表中寻找下一个空闲的位置来存储键值对。常见的探测策略有线性探测（Linear Probing）、二次探测（Quadratic Probing）和双重哈希（Double Hashing）等。线性探测是最简单的方法，当发生冲突时，直接查看下一个位置是否空闲，如果空闲则插入，否则继续查看下一个位置，直到找到空闲位置或遍历完整个哈希表。例如，对于哈希表[null, null, “Alice”:95, null, null]，如果要插入 “Bob” 的成绩，且 “Bob” 的哈希值与 “Alice” 相同，发生冲突，那么线性探测会查看下一个位置（索引为 3）是否空闲，若空闲则插入 “Bob” 的键值对。开放地址法的优点是不需要额外的链表空间，但缺点是容易产生聚集现象，即多个冲突的键值对集中在哈希表的某个区域，导致查找效率下降。

8.3 哈希映射的应用场景

哈希映射在实际编程中有广泛的应用场景，以下是一些常见的例子：

缓存系统：在缓存系统中，哈希映射可以用于存储缓存数据。键可以是缓存数据的标识符，值是实际的缓存数据。当需要读取数据时，首先在哈希映射中查找，如果找到则直接返回缓存数据，避免了重复读取数据库或其他数据源，提高了系统的性能。例如，在一个 Web 应用中，将频繁访问的网页内容缓存起来，以用户请求的 URL 作为键，网页内容作为值存储在哈希映射中。当用户再次请求相同的 URL 时，直接从哈希映射中获取网页内容返回给用户，减少了服务器的负载和响应时间。
统计单词出现次数：在文本处理中，经常需要统计文本中每个单词出现的次数。可以使用哈希映射来实现，将单词作为键，出现次数作为值。遍历文本中的每个单词，若单词已存在于哈希映射中，则将其对应的值加 1；若单词不存在，则在哈希映射中插入该单词，并将值初始化为 1 。例如，对于文本 “apple banana apple orange banana apple”，使用哈希映射统计单词出现次数，最终得到{“apple”: 3, “banana”: 2, “orange”: 1} 。这样可以方便地获取每个单词的出现频率，用于文本分析、词频统计等任务。
数据库索引：数据库中的索引可以看作是一种哈希映射。例如，在关系型数据库中，索引可以加速数据的查询。假设我们有一个用户表，包含用户 ID、姓名、年龄等字段。如果我们经常根据用户 ID 来查询用户信息，那么可以为用户 ID 字段创建一个索引。这个索引实际上就是一个哈希映射，键是用户 ID，值是指向用户表中对应记录的指针或行号。通过哈希映射，数据库可以快速定位到指定用户 ID 的记录，大大提高了查询效率。
编译器符号表：在编译器中，符号表用于存储程序中定义的变量、函数等符号的信息。哈希映射可以作为符号表的底层实现，将符号名作为键，符号的相关信息（如类型、作用域、内存地址等）作为值。当编译器解析程序代码时，遇到一个符号名，就可以通过哈希映射快速查找该符号的相关信息，进行语义分析和代码生成。例如，在 C++ 程序中，定义了变量int num = 10;，编译器会将 “num” 作为键，将其类型（int）、初始值（10）等信息作为值存储在符号表（哈希映射）中。当后续代码中使用 “num” 时，编译器可以从符号表中快速获取其相关信息。