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

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

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

示例:

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

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

java代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        int a[] = new int[2];         
        int x=0;
        for(int i=0;i<nums.length;i++ ){
            for(int j=i+1;j<nums.length;j++){
                if(nums[i]+nums[j]==target){
                    a[x]=i;
                    x++;
                    a[x]=j;
                }
            }
        }
        return a;
    }
}

 

python:

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        results=[]
        for i in range(len(nums)):
            for j in range(i+1,len(nums)):
                if nums[i] + nums[j] == target:
                    results.append(i)
                    results.append(j)
        return results

以上算法复杂度都为O(n^2),空间复杂度为O（1）属于暴力算法。且思路都一样。

优化：

对于复杂度为O(n^2)，我们想要降低到O(n)。那么就需要去掉一个for循环。

思路：第一次执行for循环时,用目标值减去当前遍历的数据，算出来这个值与列表中的其他元素比较。如果存在则返回这个结果。那么需要一个字典的方式去存储这些数据（java中hash表也是有这种功能，hash表可以通过key直接查询）。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        data = {}
        for i in range(len(nums)):
            data[nums[i]]=i
        for i in range(len(nums)):
            a = target-nums[i]
            if a in data :
                return i,data[a]

现在考虑是否可以将上述方法中的第一个for循环去掉。

思路：可以一边遍历，一边添加。就是说你在遍历计算机后比较这个对应的字典是否存在。如果不存在继续比较下一个，并且把当前这个放入比较列表中。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        data = {}
        for i in range(len(nums)):
            a = target-nums[i]
            if a in data :
                return data[a],i
            else:
                data[nums[i]]=i

以上代码复杂度为O(n),但是空间复杂度变为了O（n）