LeetCode解题实战：Python与C++编程技巧

May Wei

于 2024-09-22 13:41:13 发布

阅读量1.5k

点赞数 10

本文链接：https://blog.csdn.net/weixin_29363791/article/details/142447614

版权

本文还有配套的精品资源，点击获取

简介：LeetCode汇集了大量算法和数据结构问题，本资料集针对Python和C++两种编程语言，在LeetCode上解决算法问题的策略与实践。Python以其简洁语法和标准库在数据科学和算法实现中占据优势，而C++则以其性能优势在需要高性能计算的场景中受到青睐。本资料集通过实例解析，助你深刻理解Python和C++在算法问题解决中的应用，包括搜索、排序、图论、动态规划等多种算法，并提供典型的LeetCode问题的两种语言解决方案。

1. LeetCode平台和算法数据结构问题介绍

1.1 LeetCode平台概述

1.1.1 LeetCode的发展历程

LeetCode成立于2011年，最初作为程序员面试准备平台起步。随着时间的发展，它不仅提供了丰富的编程题目，还涵盖了从初级到高级的多种编程语言，帮助程序员通过算法题目来提升编码能力和解决问题的技巧。

1.1.2 平台特点与功能介绍

LeetCode以用户友好的界面、实时反馈和详尽的题目分类而受到广大开发者的喜爱。它提供了在线编程环境，让开发者能够在多种编程语言中测试自己的代码。此外，平台还具备社交功能，可以让用户与世界各地的程序员互动，分享解题思路和经验。

1.2 算法与数据结构基础

1.2.1 算法的重要性和应用场景

算法是解决计算问题的一系列定义良好的指令集合。在软件开发中，算法的效率直接影响到产品的性能和用户体验。无论是搜索引擎、社交网络还是电子商务平台，算法都是它们背后不可或缺的技术力量。

1.2.2 数据结构的核心概念与类型

数据结构是指组织和存储数据的一种方式，它包括线性结构、树形结构、图结构等。掌握不同的数据结构能够帮助开发者更高效地处理数据，如数组、链表、栈、队列、树、图等。了解这些数据结构的特性及其适用场景，对于优化算法性能至关重要。

2. Python在数据科学和算法实现中的优势

Python自20世纪90年代初诞生以来，已经成为数据科学和算法实现领域中最流行的编程语言之一。其受欢迎程度不仅体现在学术界和研究领域，而且在工业界和软件开发中也有着广泛的应用。本章节将深入探讨Python语言的特性、数据科学中的应用，以及在算法实现中的实际案例分析。

2.1 Python语言特性

2.1.1 Python的简洁语法和易读性

Python的设计哲学强调代码的可读性和简洁的语法（尤其是使用空格缩进划分代码块，而非使用大括号或关键字）。这种设计使得Python代码通常比其他语言更加简洁易读。

Python语言的核心关键字非常少，这使得学习曲线相对平缓。例如，循环和条件语句的语法非常直观，可以用以下代码块展示：

# 条件语句示例
if x > 0:
    print("x 是一个正数")
elif x == 0:
    print("x 是零")
else:
    print("x 是一个负数")

# 循环语句示例
for i in range(5):
    print(i)

在逻辑判断和循环结构中，Python利用缩进来明确代码块的层次关系，这样的语法设计减少了语言的复杂度，同时也降低了出错的可能性。

2.1.2 Python的广泛库支持和应用场景

Python的一个显著特点是拥有大量预构建的库，可以轻松地扩展语言的功能。这些库包括但不限于科学计算、数据分析、机器学习、网络爬虫、网页开发、系统管理等。

科学计算库： NumPy 和 SciPy 提供了高性能的数组操作和科学计算功能。
数据分析库： Pandas 提供了易于操作的数据结构和数据分析工具。
机器学习库： scikit-learn 和 TensorFlow 支持机器学习和深度学习模型的构建。

这些库的广泛使用极大地促进了Python在数据科学领域的应用，使其成为这一领域的主导编程语言。

2.2 Python在数据科学中的应用

2.2.1 数据处理与分析工具介绍

数据科学的核心是数据的处理和分析。Python通过各种第三方库，如Pandas、NumPy和Matplotlib，为数据分析提供了强大的支持。

Pandas： 提供了DataFrame和Series等数据结构，它们是高效处理表格数据和时间序列数据的关键。
NumPy： 为Python提供了高性能的多维数组对象和相关工具，非常适合执行科学计算。
Matplotlib： 提供了丰富的图表绘制工具，可以帮助数据科学家将数据可视化。

2.2.2 机器学习框架与Python的结合

Python在机器学习领域同样表现突出，几乎所有的机器学习框架都提供了Python接口。其中最著名的包括scikit-learn、TensorFlow和Keras。这些框架使得构建、训练和部署机器学习模型变得简单高效。

scikit-learn： 作为机器学习的通用库，提供了许多简单有效的工具进行数据挖掘和数据分析。
TensorFlow： 由Google开发，是一个强大的端到端平台，用于大规模深度学习。
Keras： 一个高层神经网络API，能够在TensorFlow、CNTK或Theano之上运行。

2.3 Python算法实现案例分析

2.3.1 经典算法的Python实现

Python语言的简洁性非常适合实现算法原型和快速开发。下面是一个使用Python实现经典排序算法的例子——冒泡排序：

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n-i-1):
            if arr[j] > arr[j+1]:
                arr[j], arr[j+1] = arr[j+1], arr[j]
    return arr

# 测试冒泡排序算法
unsorted_array = [64, 34, 25, 12, 22, 11, 90]
sorted_array = bubble_sort(unsorted_array)
print("排序后的数组:", sorted_array)

该算法的Python代码非常直观，并且易于理解，体现了Python在算法实现中的简洁性。

2.3.2 Python在实际问题中的应用

Python在处理实际问题时也非常灵活。下面是一个使用Python和NumPy库处理数值计算的例子：

import numpy as np

# 创建一个NumPy数组
array = np.array([1, 2, 3, 4, 5])

# 对数组进行元素平方运算
squared_array = np.square(array)

# 打印结果
print("平方后的数组:", squared_array)

以上代码展示了如何利用NumPy库快速进行数组操作，这在数据分析和科学计算中非常实用。

本章节重点介绍了Python语言的核心特性，以及它在数据科学和算法实现中的强大应用。接下来的章节将探讨C++在高性能计算中的优势，以及Python和C++在LeetCode问题解决中的实际应用案例。

3. C++在高性能计算中的优势及特性应用

3.1 C++语言特性

3.1.1 C++的性能优化能力

C++作为一门历史悠久且功能强大的编程语言，在系统编程和高性能计算领域有着无可比拟的优势。这种优势主要源于其底层操作的能力和对硬件的高效访问。C++编写的代码往往能够提供接近底层语言（如C）的执行效率，这得益于它的内存管理和性能优化特性，如直接内存访问、指针算术等。更重要的是，C++支持面向对象的范式，这使得代码更容易维护和重用。

性能优化的关键点

内联函数： 减少函数调用开销。
模板编程： 允许编译时多态，避免运行时多态的性能损失。
智能指针： 自动管理内存，减少内存泄露的可能性。
并行和并发库： 如 <thread> , <atomic> , <future> 等支持多线程编程。

3.1.2 C++面向对象编程的优势

C++的面向对象编程（OOP）特性让它不仅在性能上表现出色，而且在构建复杂系统时也游刃有余。OOP的主要特点包括封装、继承和多态性，它们允许开发者定义清晰的接口和抽象，使得代码更加模块化和易于扩展。

面向对象编程的好处

代码可重用性： 通过继承和模板编程可以实现代码的重用。
模块化： 封装好的类可以独立于其他部分修改和测试。
易维护： 明确的接口定义和类结构使得代码易于理解和维护。

3.2 C++在系统编程中的应用

3.2.1 C++与操作系统和网络编程

C++在操作系统和网络编程中的应用非常广泛，许多底层的系统软件、网络服务器和客户端都是用C++编写的。其优势在于能够实现高性能的网络通信和对系统资源的有效管理。例如，使用C++可以编写高性能的异步网络服务器，实现复杂的协议处理。

关键应用技术点

网络库： 如 Boost.Asio 用于高效的网络编程。
系统调用： C++可以进行底层的系统调用，控制和管理资源。

3.2.2 C++在图形界面和游戏开发中的应用

C++在图形界面和游戏开发中同样扮演着重要角色。游戏引擎如Unreal Engine和Unity的底层就是用C++编写的。C++支持高效率的图形渲染，能够利用现代图形硬件进行高效的3D渲染。同时，由于其性能优化能力，C++可以用来开发复杂的物理引擎和AI算法。

游戏开发中的优势

高效的渲染性能： 直接与图形API如OpenGL和DirectX交互。
快速的物理计算： 利用高性能计算特性进行复杂的物理模拟。
AI和逻辑处理： 用C++实现游戏逻辑和AI算法，保证效率。

3.3 C++算法实现案例分析

3.3.1 高级算法在C++中的实现

C++因其性能优化能力和强大的标准库支持，成为实现高级算法的理想选择。例如，C++标准模板库（STL）提供了丰富多样的数据结构和算法实现，这些都是高效算法实现的基础。

典型算法实现

动态规划： 使用STL中的数据结构，如vector和map，进行高效的状态转移。
图算法： 利用STL中list或vector实现邻接表，进行深度优先搜索（DFS）和广度优先搜索（BFS）。

3.3.2 C++在解决高性能计算问题中的优势

在解决高性能计算问题时，C++的性能优势变得尤为明显。内存管理、直接硬件交互能力以及并行算法的实现，都使得C++在处理大规模数据和复杂算法时具有更高的效率。

高性能计算的优势

资源管理： 精确控制内存分配和数据布局。
并行计算： 利用C++的多线程库支持，实现数据的并行处理。
数值计算： 高效的数值计算库如Armadillo和Eigen，可以用于矩阵运算等高级算法。

代码示例：

#include <iostream>
#include <vector>
#include <thread>
#include <future>

// 使用C++11的线程库创建并行计算
void compute_something(int data) {
    // 模拟耗时计算
    std::this_thread::sleep_for(std::chrono::milliseconds(100));
    std::cout << "Data: " << data << " processed by thread " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::vector<std::future<void>> futures;
    for (int i = 0; i < 10; ++i) {
        // 用lambda表达式创建异步任务
        futures.emplace_back(std::async(std::launch::async, [i](){ compute_something(i); }));
    }

    // 等待所有异步任务完成
    for (auto &future : futures) {
        future.get();
    }

    return 0;
}

逻辑分析： 上述代码展示了使用C++11的 <future> 和 <thread> 库创建异步任务的能力。通过 std::async ，我们可以启动一个新线程来并行执行计算任务，并且 std::future 对象允许我们等待异步任务完成。这使得我们可以充分利用现代多核处理器的计算能力进行并行处理，从而提升性能。

参数说明： - std::async ：启动一个异步任务。 - std::launch::async ：指定任务应该在新线程上异步运行。 - std::future.get() ：阻塞等待异步任务完成。

在本章节中，我们首先探讨了C++语言特性及其在高性能计算中的优势，包括性能优化能力和面向对象编程的特点。然后，我们深入了解了C++在系统编程中的应用，尤其是在操作系统和网络编程以及图形界面和游戏开发中的应用。接着，我们通过具体的案例分析，展示了如何在C++中高效实现高级算法。通过一个并行计算的代码示例，我们理解了如何利用C++的多线程库来解决高性能计算问题。这些讨论为读者展示了C++作为一种高性能编程语言在解决计算问题方面的强大能力。

4. Python和C++在LeetCode问题解决中的实例解析

在LeetCode中，解决编程问题的方式和选择的编程语言对解题效率和结果的准确性有着直接影响。在这一章节中，我们将深入探讨Python和C++在LeetCode问题解决中的实际应用，具体问题的语言实现对比，以及实现效率和代码可读性的对比分析。

4.1 问题解决策略和语言选择

4.1.1 不同类型问题的语言适用性分析

在解决LeetCode问题时，选择合适的编程语言可以大大提高开发效率和解题的准确度。通常，我们可以根据以下标准进行语言选择：

算法与数据结构问题 ：Python由于其简洁的语法和丰富的库支持，在实现算法原型时往往更为高效。例如，使用Python的内置字典和列表等数据结构可以方便快速地实现复杂的逻辑。
性能要求极高的问题 ：C++提供了更接近硬件层面的操作，能够在性能上做出更细致的优化。在需要极致性能的应用场景下，C++无疑是更好的选择。
系统编程和并发问题 ：C++提供的系统级操作和多线程支持比Python更加丰富和灵活，适用于需要深入系统层面处理的复杂问题。

4.1.2 语言选择对解题效率的影响

不同的编程语言在解题效率方面会有所不同，主要体现在以下几个方面：

语法简洁度 ：Python的语法更简洁，变量声明和循环等控制结构的写法更加直观，可以减少编码时间。
标准库的丰富程度 ：Python拥有广泛的库支持，尤其是数据处理、算法等方面的库，可以大幅提高解题速度。
运行时性能 ：C++由于其编译型语言的特性，在执行效率上通常优于Python，这使得对于性能要求极高的问题，C++能提供更快的执行速度。

4.2 具体问题的语言实现对比

4.2.1 同一问题在Python和C++中的不同实现方式

以一个常见的LeetCode问题“两数之和”为例，我们可以展示同一问题在Python和C++中的不同实现方式。这个问题要求从一个数组中找到两个数，使得它们的和等于一个特定的值。

Python实现方式 ：

def two_sum(nums, target):
    num_dict = {}
    for i, num in enumerate(nums):
        if target - num in num_dict:
            return [num_dict[target - num], i]
        num_dict[num] = i
    return []

# 示例
print(two_sum([2, 7, 11, 15], 9))  # 输出: [0, 1]

C++实现方式 ：

#include <vector>
#include <unordered_map>

std::vector<int> twoSum(std::vector<int>& nums, int target) {
    std::unordered_map<int, int> num_map;
    for (int i = 0; i < nums.size(); ++i) {
        if (num_map.find(target - nums[i]) != num_map.end()) {
            return {num_map[target - nums[i]], i};
        }
        num_map[nums[i]] = i;
    }
    return {};
}

// 示例
#include <iostream>
int main() {
    std::vector<int> nums = {2, 7, 11, 15};
    int target = 9;
    std::vector<int> result = twoSum(nums, target);
    std::cout << "[" << result[0] << ", " << result[1] << "]" << std::endl;
    return 0;
}

4.2.2 实现效率和代码可读性的对比分析

在上述示例中，Python版本的代码更简洁，更符合Python的风格。Python中的字典直接支持我们快速查找与目标值相对应的数字。而C++版本中使用了unordered_map来模拟字典的行为，虽然在语法上稍微复杂一点，但在运行时通常会更快。

代码可读性 ：

Python的代码通常更加直观和易于理解，适合快速原型开发和算法研究。
C++虽然代码稍显复杂，但它提供了更多的控制，适用于需要对性能进行精细优化的场景。

实现效率 ：

Python由于其解释型语言的特性，在运行时效率上通常低于C++。
C++提供了内存直接管理和更精细的控制，特别是在大数据量和需要高性能计算的情况下，C++会表现得更好。

通过这些对比，我们可以看到，选择不同的编程语言在解决问题时不仅影响了编码过程的便捷性，也直接影响了解决方案的性能和可维护性。在实际应用中，开发者需要根据问题的特点和实际需求进行合理的语言选择。

5. 搜索、排序、图论、动态规划等多种算法应用

5.1 搜索算法

搜索算法是解决一系列问题的基础，通常用于在一定空间中寻找特定目标或路径。按照搜索方式的不同，可以将搜索算法分为两大类：无信息搜索和有信息搜索。

无信息搜索算法

无信息搜索算法不利用任何关于搜索空间的特殊信息，常见的有深度优先搜索（DFS）和广度优先搜索（BFS）。

深度优先搜索(DFS)

深度优先搜索是一种用于遍历或搜索树或图的算法。它从一个顶点开始，追踪一条边直到尽头，然后回溯到上一个分叉点，并沿着另一条路径继续搜索。

在DFS中，通常使用递归或栈实现。下面是一个递归实现DFS的例子：

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)
    for next in graph[start] - visited:
        dfs(graph, next, visited)
    return visited

# 示例图结构
graph = {
    'A': {'B', 'C'},
    'B': {'A', 'D', 'E'},
    'C': {'A', 'F'},
    'D': {'B'},
    'E': {'B', 'F'},
    'F': {'C', 'E'}
}

# 执行DFS
dfs(graph, 'A')

这段代码定义了一个递归函数 dfs ，它接受一个图、起始节点以及一个可选的已访问节点集合。函数输出当前访问的节点，并对其每个未访问的邻居递归调用自身。

广度优先搜索(BFS)

广度优先搜索按照距离起点的远近顺序访问节点。在树或图中，它通常利用队列来实现，逐步探索所有邻近节点。

from collections import deque

def bfs(graph, start):
    visited = set()
    queue = deque([start])
    while queue:
        vertex = queue.popleft()
        if vertex not in visited:
            print(vertex)
            visited.add(vertex)
            queue.extend(set(graph[vertex]) - visited)
    return visited

# 执行BFS
bfs(graph, 'A')

上面的代码使用队列来控制节点的访问顺序，每访问一个节点，就将其未访问的邻居节点加入队列。

5.2 排序算法

排序算法用来将一组数据按照一定的顺序进行排列。根据时间复杂度和空间复杂度的不同，可以分为多个类别，包括冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序等。

排序算法的原理与比较

冒泡排序 ：通过重复地交换相邻逆序的元素来对列表进行排序。尽管易于实现，但其时间复杂度较高。
选择排序 ：每次从未排序的列表中选出最小（或最大）的元素，放在已排序序列的末尾。其时间复杂度较为固定。
插入排序 ：构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。对于小规模数据，插入排序效率较高。
归并排序 ：采用分治策略，分而治之。将待排序的序列分成两个子序列，对每个子序列进行排序，然后将排序好的子序列合并成最终的排序序列。
快速排序 ：通过一个划分操作将数据分为独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再递归地对这两部分数据分别进行快速排序，整个排序过程递归进行。
堆排序 ：利用堆这种数据结构所设计的一种排序算法，堆是一种近似完全二叉树的结构，并同时满足堆积的性质。即子节点的键值或索引总是小于（或者大于）它的父节点。

在选择排序算法时，需要根据数据量大小和数据特性进行合理选择。例如，对于小规模数据，插入排序是一个不错的选择；而对于大规模数据，快速排序或归并排序则更为高效。

5.3 图论算法

图论是数学的一个分支，用来研究由对边连接的节点集合。图论算法广泛应用于网络分析、社交网络、交通规划等领域。

图的表示和基本操作

图可以通过多种方式表示，最常见的包括邻接矩阵和邻接表。

邻接矩阵 ：一个二维数组，其中 matrix[i][j] 表示节点 i 和节点 j 之间边的权重，如果 i 和 j 之间没有边连接，则值为无穷大或某个特定值表示不可达。
邻接表 ：一种通过链表或者字典来表示图的数据结构，邻接表中每个节点都有一个列表，其中包含所有与该节点相连的其他节点。

基本操作包括但不限于：

添加节点和边
删除节点和边
查找节点和边
路径查询

图论算法中最常见的问题类型包括：

最短路径问题 ：找出两个节点之间长度最短的路径。
最小生成树问题 ：找出一个无向图的所有节点之间的最小连接集合。
网络流问题 ：计算网络中最大流量的分配。

常见图论问题及其算法解决方案

最短路径问题 ：可以使用Dijkstra算法或Floyd-Warshall算法求解。Dijkstra算法适用于没有负权边的图，而Floyd-Warshall算法适用于包含负权边的图。
最小生成树问题 ：可以使用Kruskal算法或Prim算法。Kruskal算法通过贪心策略选择边，而Prim算法从某一节点出发不断扩展最小生成树。
网络流问题 ：可以使用Ford-Fulkerson算法或Edmonds-Karp算法。Ford-Fulkerson算法通过不断增加流量直到不能再增加为止，而Edmonds-Karp算法是Ford-Fulkerson算法的一个实现，它使用广度优先搜索找到增广路径。

图论算法在解决实际问题时非常强大，例如在社交网络中分析影响力最大的人，或者在地图中规划出最短路径。

5.4 动态规划算法

动态规划是解决多阶段决策问题的一种方法。它将复杂问题分解为更简单的子问题，并将子问题的解保存起来，避免重复计算。

动态规划的基本思想和应用

动态规划通常用一个数组来保存子问题的解，通过解决小问题来逐步构建大问题的解。这种方法要求问题具有最优子结构和重叠子问题两个特性。

最优子结构 ：问题的最优解包含了其子问题的最优解。
重叠子问题 ：在解决问题的过程中，相同的子问题会被多次计算。

动态规划的一个经典问题就是斐波那契数列求解。

动态规划在复杂问题中的应用实例

动态规划在许多领域都有应用，如金融领域的投资决策、供应链管理、生物信息学中的序列比对等。

以“最大子序列和”问题为例，问题的目标是找出一个序列中和最大的连续子序列。以下是动态规划解决方案的一个简单实现：

def max_subarray_sum(arr):
    max_ending_here = max_so_far = arr[0]
    for x in arr[1:]:
        max_ending_here = max(x, max_ending_here + x)
        max_so_far = max(max_so_far, max_ending_here)
    return max_so_far

# 示例数组
arr = [-2, -3, 4, -1, -2, 1, 5, -3]
print(max_subarray_sum(arr))  # 输出应该是7，因为子序列[4, -1, -2, 1, 5]和最大

在这段代码中， max_ending_here 变量用于跟踪当前最大子序列的和，而 max_so_far 变量记录到目前为止所遇到的最大子序列和。动态规划算法通过这种方式避免了重复的计算。

通过以上章节，我们可以看到搜索、排序、图论和动态规划等多种算法在解决问题中的广泛应用和重要性。这些算法不仅在理论上有丰富的研究，也在实际应用中发挥着巨大作用。理解并掌握这些算法，是提升个人解决问题能力的关键步骤。

6. 典型LeetCode问题解决方案（如两数之和）展示

在本章中，我们将深入探讨如何通过算法解决实际问题，并以LeetCode上一个经典问题“两数之和”为例，详细分析算法设计和解决方案的实现。此问题不仅考察编程人员对数据结构和算法的掌握程度，而且也是检验解题者能否熟练运用编程语言解决问题的一个重要指标。

6.1 算法问题的分析与解决方法

6.1.1 如何将实际问题转化为算法问题

在开始编码之前，理解并正确转化问题至可被算法处理的形式至关重要。对于“两数之和”这个问题，它可被描述为：给定一个整数数组 nums 和一个目标值 target ，找出数组中和为目标值的两个数，并返回它们的数组下标。

首先，我们需要确定问题的输入输出格式，明确数据范围和限制条件。例如，数组中的每个元素都是唯一的，且一定存在一对元素可以加起来等于目标值。在此基础上，思考算法可以采用什么样的策略和数据结构，以及如何优化时间空间复杂度。

6.1.2 算法设计与优化策略

在设计算法时，需要考虑不同方法的优缺点和适用场景。对于“两数之和”问题，可以采用的策略包括：

暴力法 ：通过两层循环遍历数组，直接寻找是否存在两个数的和等于目标值。
哈希表法 ：使用哈希表记录数组元素与下标的关系，遍历数组时，检查当前元素的补数（ target - 当前元素）是否在哈希表中。

暴力法简单直观但效率较低，复杂度为O(n^2)。而哈希表法的时间复杂度降低至O(n)，空间复杂度为O(n)，通常是我们解决问题的首选。

6.2 具体问题解决方案展示

6.2.1 “两数之和”问题的解法分析

在展示代码实现之前，让我们先分析一下采用哈希表法的解题策略：

创建一个哈希表用于存储数组中每个元素的值及其对应的索引。
遍历数组，对于每个元素：
计算当前元素与目标值的差值。
检查哈希表中是否存在该差值。
如果存在，返回当前元素的索引和差值对应的索引。
如果不存在，将当前元素的值和索引存入哈希表。
如果遍历完数组都没有找到解决方案，则返回空。

6.2.2 解决方案的代码实现与讲解

下面，我们以Python语言实现上述算法策略：

def twoSum(nums, target):
    # 创建哈希表
    hash_map = {}
    # 遍历数组
    for i, num in enumerate(nums):
        # 计算差值
        complement = target - num
        # 检查差值是否在哈希表中
        if complement in hash_map:
            # 返回结果
            return [hash_map[complement], i]
        # 存储当前元素和索引
        hash_map[num] = i
    # 如果没有找到解决方案，返回空
    return []

这段代码的核心在于构建一个哈希表来减少查询时间，从而将时间复杂度从O(n^2)降低到O(n)。代码中， enumerate 函数用于同时获取数组元素的值和索引，而 hash_map 用于快速定位元素的索引。我们利用哈希表的快速查找特性，避免了不必要的重复计算，大大提高了算法效率。