LeetCode系列1.两数之和

前言

参加掘金社区一个刷题打卡的活动，简单来说，就是在3月13号（含）之前在掘金社区发布10篇有关算法和刷题的文章就行，完成后会有一些礼品，比如，掘金小册的1折卡等等。这一篇分享的是关于LeetCode第1题的解决思路和Python 3、JavaScript解题代码。

题目描述

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

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

**难度：**简单

示例：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
原因：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]。

提示：

• 只会存在一个有效答案
• 2 <= nums.length <= 103
• -109 <= nums[i] <= 109
• -109 <= target <= 109

解题思路

刚看到这道题，脑海中蹦出几个字：两层循环。第一层循环遍历依次遍历整个数组，第二层循环从第一层循环的索引值开始遍历数组，然后判断第一层循坏和第二次循坏的当前值的总和是不是target，如果是，则返回两层循坏的索引值，如果不是，则继续循环，直至循环停止。网上也这种方式为暴力枚举。 既然成为暴力求解法，那肯定有优化方法，有没有可能牺牲掉一些空间性能，来换取更快的执行速度呢？我们接着来看。

仔细想想上面的解题方式，你会发现，这种方式会记录数组中当前元素，然后在数组中还没有遍历的元素中找到和一个匹配的结果值，已经遍历过的元素被丢弃了，白白消耗了循环时间，我们能不能把遍历的元素利用起来呢，从这些以遍历的元素中查找和当前值匹配的值。这就需要借用某种方式把已遍历的元素和其对应的索引成对的记录下来，这时候你会想到什么呢，是不是对象或者字典呢？对了，可以通过字典来存储以遍历的值。我们把以遍历的元素作为字典的key，它对应的索引值作为value。在后续的数组的遍历过程中，可以通过判断target - currentValue是不是字典中的某个key来求解。

接下来，将会介绍Python3和JavaScript如何来求解这个问题，其中Python3会介绍上述2中求解方法，JavaScript只介绍第2中求解方法。

AC代码

Python3

暴力迭代法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums_length = len(nums)

        for i in range(nums_length):
            for j in range(i + 1, nums_length):
                if nums[i] + nums[j] == target:
                    return [i, j]
        
        return [0, 1]

字典查找法

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        nums_length = len(nums)
        traversed_num = dict()

        for i in range(nums_length):
            if target - nums[i] in traversed_num:
                return [traversed_num[target - nums[i]], i]
            
            traversed_num[nums[i]] = i
        
        return []

JavaScript

var twoSum = function(nums, target) {
    const hashTable = new Map()

    for(let i = 0; i < nums.length; i++) {
        if (hashTable.has(target - nums[i])) {
            return [hashTable.get(target - nums[i]), i]
        }

        hashTable.set(nums[i], i)
    }

    return []
};

总结

暴力迭代法，因为有2层遍历，所以它的时间复杂度为O(n^2)；在实现过程中，定义的变量仅有3个，它的空间复杂度为O(1)。

字典查找法，只需要遍历依次，它的时间复杂度为O(n)；在实现过程中，需要创建个字典来存储以遍历的元素值，它的空间复杂度为O(n)，相比于暴力迭代法，该方法牺牲了一些空间，来换取更快的执行速度。

题外话：JavaScript中的Map

Map是ES6中新增的一种集合工具，Map是一种存储许多键值对的有序列表，其中，键和值支持所有的数据类型。相比于对象（object）中的属性名，Map中的键使用Object.is()来做等价性判断，而对象中的属性名作比较时，总会强制转为字符串类型。举个例子，数值型的5和字符串的"5"在Map中是判断为两种类型，对应2个键，而在对象中，两者比较时，5会被强制性转为"5"，被看作同一个属性名。

Map的初始化方式：使用new Map()的方式来创建实例，在初始化时，也可以向Map的构造函数传入一个数组，但这个数组必须是二维数组，例如：

let mapInstance = new Map([["name", "jiaoxn"], ["age", 27]])

其中，name和age作为Map中的键，jiaoxn和27作为对应的值。

Map的方法：

• has(key)，判断Map实例中是否存在某个key
• delete(key)，从Map实例中删除执行的key及其对应的值
• clear()，移除Map实例的所有键值对
• set(key, value)，向Map实例中增加键值对
• get(key)，获取Map实例中的某个key的值
• foreach()，遍历Map实例中的元素的值，参数是一个回调函数，该回调函数有三个参数：值、键名称和实例本身。

let mapInstance = new Map()

mapInstance.set('name', 'jiaoxn')
mapInstance.set('age', 27)

mapInstance.foreach((value, key, ownerMap) => {
    console.log(value, key)
    console.log(ownermap)
    console.log(ownermap === mapInstance)
})