LeetCode刷题--1.两数之和（C、python、java）

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

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

示例:

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

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

暴力解法（C语言）：

int* twoSum(int* nums, int numsSize, int target) {
    static int  a[2] = {0};
    int i ,j;
    for(i = 0 ;i < numsSize-1 ; i++)
        for(j = i+1;j < numsSize; j++)
        {
            if(nums[i] + nums[j] == target)
            {
                a[0] = i;
                a[1] = j;
                return a;
            }
        }

return 0;        
}

这里需要注意的就是要把数组设置成static的，因为因为如果不用静态的话，数组的生命周期就是从定义的地方到函数结束，函数运行结束，这个内存也就释放掉了。返回的是数组的首地址，一旦函数运行结束，这个地址里的东西就变成空了，所以要用静态数组延长数组的生命周期。

主要就是冒泡的思想，整个循环遍历一波，这里的时间复杂度是o（），空间复杂度是o（1） ，时间复杂度是非常的高了。

python:

方法一：直接暴力循环解决问题

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        size = len(nums)
        for i, m in enumerate(nums):
            j = i + 1
            while j < size:
                if target == m + nums[j]:
                    return [i,j]
                else:
                    j += 1

这里有一个enumerate（）函数，主要的功能就是遍历整个列表，其中第一个参数 i 是列表的下标，从0开始，第二个参数是列表的值。但是时间太长了。直接超出时间限制。

方法二：用了字典

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        if not nums:
            return 0;
        d = dict()
        for i,item in enumerate(nums):
            tmp = target  - item
            if tmp in d:
                return [i,d[tmp]]
            d[item] = i
        return None

d[item] = i，代码的字典值不是一次给完的，而是试，如果不知tmp，就直接存入字典，继续计算，如果是tmp都计算出结果了，后面都不用存了，节省空间。

d[item] 是给value的值。。。python确实比较耗时，比c的暴力还要费时间，用py主要是练一下py的语法。。。。

这里将python的代码进行连写，反正这样的看着不友好，阅读星也太差了吧

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = dict()
        for i, item in enumerate(nums):
            if d.get(target - item) is not None:
                return [d.get(target - item),i]
            d[item] = i
        

java用了哈希函数，感觉和py的字典一样的，代码如下：

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

 

这里可以看到java用了两次迭代，其实一次迭代完全可以搞定

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement)) {
            return new int[] { map.get(complement), i };
        }
        map.put(nums[i], i);
    }
    throw new IllegalArgumentException("No two sum solution");
}

我擦，感觉和py的代码一模一样啊。。。。。