hot100-1

两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

range 是一个在 Python 中常用的函数，用于生成一个指定范围内的数字序列。它的常见用法有三种形式：

示例：
使用 range(stop) 形式：

for i in range(5):
    print(i)
# 输出：0 1 2 3 4

使用 range(start, stop) 形式：

for i in range(2, 6):
    print(i)
# 输出：2 3 4 5

使用 range(start, stop, step) 形式：

for i in range(1, 10, 2):
    print(i)
# 输出：1 3 5 7 9

range(stop)：生成从 0 开始到 stop-1 的数字序列。
range(start, stop)：生成从 start 开始到 stop-1 的数字序列。
range(start, stop, step)：生成从 start 开始到 stop-1 的数字序列，步长为 step。
这个函数返回的是一个可迭代的 range 对象，可以用于循环中，或者通过转换成列表等数据结构来使用。

def find_two_sum(nums, target):
    for i in range(len(nums)):
        for j in range(i + 1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]
    return None

直接两个for解决，不过这段代码中的 return None 语句应该放在外层循环结束后，而不是内层循环结束后。如果在内层循环的第一次迭代中没有找到符合条件的数对，就会立即返回 None。但实际上，我们需要等到所有的可能组合都被遍历完才能确定是否有符合条件的数对。

for i in range(len(nums)):：这是外层循环，用于遍历列表中的每个元素。i 是当前元素的索引。

j = i + 1：在内层循环开始之前，将 j 初始化为 i 的下一个索引。这是为了避免重复比较已经比较过的元素对。

for j in range(j, len(nums)):：这是内层循环，用于遍历从 j 开始到列表末尾的每个元素。j 是当前元素的索引。

if nums[i] + nums[j] == target:：在每次内层循环中，检查当前元素 nums[i] 和 nums[j] 的和是否等于目标值 target。

如果和等于 target，则返回一个包含当前索引 i 和 j 的列表 [i, j]，表示找到了符合条件的两个数的索引。

如果内层循环结束后仍未找到满足条件的数对，则返回 None，表示未找到。

进阶：你可以想出一个时间复杂度小于 O(n2) 的算法吗？

当需要寻找列表中两个数的组合，使它们的和等于目标值时，我们可以利用字典（哈希表）来实现一个时间复杂度小于 O(n^2) 的算法。

这种方法的思路是：

遍历列表，对于每个元素，计算目标值与当前元素的差值。
检查差值是否在字典中存在，如果存在，说明找到了符合条件的两个数。
如果差值不在字典中，则将当前元素添加到字典中。
这种方法的关键在于利用字典的快速查找特性，将查找的时间复杂度降低到 O(1)。

以下是用 Python 实现的代码示例：

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

这个算法的时间复杂度是 O(n)，因为在最坏情况下，我们需要遍历整个列表一次。同时，由于使用了字典来存储元素及其索引的映射关系，查找操作的时间复杂度是 O(1)。因此，总体的时间复杂度是 O(n)。

基于哈希表的算法原理

1. 哈希表：哈希表是一种数据结构，它通过哈希函数将键映射到数组中的索引位置。通过在这个位置存储键值对，可以实现快速的插入、查找和删除操作。

2. 思路：对于给定的列表和目标值，我们可以遍历列表，并将每个元素及其索引存储在哈希表中。对于当前元素，我们计算目标值与当前元素的差值，然后检查这个差值是否在哈希表中存在。如果存在，则说明找到了符合条件的两个数，其索引分别为当前元素的索引和哈希表中存储的索引。

3. 算法步骤：

   • 创建一个空的哈希表。
   • 遍历列表中的每个元素，对于当前元素，计算目标值与当前元素的差值。
   • 检查差值是否在哈希表中存在，如果存在，则返回当前元素的索引和哈希表中存储的索引。
   • 如果差值不在哈希表中存在，则将当前元素及其索引存储在哈希表中。
   • 如果遍历完整个列表都没有找到符合条件的两个数，则返回 None。

举一反三

这种基于哈希表的算法不仅适用于找出列表中两个数的组合，使它们的和等于目标值，还可以应用于其他类似的问题。以下是一些类似的问题以及如何使用基于哈希表的算法来解决它们：

1. 两数之和（无序数组）：给定一个无序数组和一个目标值，在数组中找到两个数，使它们的和等于目标值。

2. 三数之和：给定一个数组和一个目标值，在数组中找到三个数，使它们的和等于目标值。

3. 四数之和：给定一个数组和一个目标值，在数组中找到四个数，使它们的和等于目标值。

4. 最长连续序列：给定一个未排序的整数数组，找出最长连续序列的长度，要求算法的时间复杂度为 O(n)。

5. 数组中重复的数据：给定一个整数数组，找出数组中重复出现的数字。

对于以上问题，都可以使用基于哈希表的算法来实现，并且时间复杂度可以控制在 O(n) 级别。这种算法思想的应用范围非常广泛，在解决一些需要查找、统计或匹配元素的问题时非常有效。

enumerate 是一个常用的 Python 内置函数，用于将一个可迭代对象组合为一个索引序列，同时返回索引和值。它的基本语法如下：

enumerate(iterable, start=0)

• iterable：要进行枚举的可迭代对象，如列表、元组、字符串等。
• start：可选参数，表示起始的索引值，默认为 0。

enumerate 函数返回一个枚举对象，其中每个元素都是一个元组，包含两个值：索引和对应的元素。

示例：

fruits = ['apple', 'banana', 'cherry']

for index, fruit in enumerate(fruits):
    print(index, fruit)

输出：

0 apple 1 banana 2 cherry

在这个示例中，enumerate 函数遍历了列表 fruits，并将列表中的每个元素和其对应的索引一一配对。在每次迭代中，返回的是一个包含索引和元素的元组 (index, fruit)，然后我们可以通过解包这个元组来获取索引和对应的元素。

enumerate 函数在循环遍历时特别有用，因为它同时提供了索引和对应的值，方便在循环中进行操作。