两数之和

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

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/probl...
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

第一种解法：

可以通过暴力搜索的方式，进行两层循环，外层按顺序循环，内层从外层元素位置开始

class Solution(object):

    def twoSum(self, nums, target):

        """

        :type nums: List[int]

        :type target: int

        :rtype: List[int]

        """

        for i, v1 in enumerate(nums):

            for j, v2 in enumerate(nums[i+1:]):

                if (v1 + v2) == target:

                    return [i, i + j + 1]

算法复杂度O(N²), 空间复杂度O(1)

第二种方法

对元素进行一次循环，并计算当前元素和目标的差，在该元素之后数组中查询该元素

class Solution(object):

    def twoSum(self, nums, target):

        """

        :type nums: List[int]

        :type target: int

        :rtype: List[int]

        """

        for i, v1 in enumerate(nums):

            t = target - v1

            try:

                index = nums[i+1:].index(t)

                return [i, index + i + 1]

            except:

                pass

算法复杂度O(n²), 空间复杂度O(1)

第三种方法

利用hash算法复杂度O(1)的特性，可以快速的查询需要数据的索引。
定义一个dict, 遍历一遍数组，将数组中的元素存储在dict中，dict的key为原数组的值value, 值为原数组的位置index
然后再次遍历数组，计算每个target-value的值，并在dict中去找

class Solution(object):

    def twoSum(self, nums, target):

        """

        :type nums: List[int]

        :type target: int

        :rtype: List[int]

        """

        result = {}

        for index, value in enumerate(nums):

            result [value] = index

        for index, value in enumerate(nums):

            t = target - value

            j = result.get(t)

            if j is not None and index != j:

                return [index, j]

算法复杂度O(n), 空间复杂度O(1)

第四种办法

对于第三种方法，可以不用把全部数组加载到dict中，这样可以只用一次循环就找到结果，同时降低使用的内存空间

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        result = {}
        for index, value in enumerate(nums):
            t = target - value
            j = result.get(t)
            if j is not None and index != j:
                return [index, j]
            result[value] = index

算法复杂度O(n), 空间复杂度O(n)