LeetCode 1.两数之和

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

Python

最容易想到的方法是枚举数组中的每一个数 x，寻找数组中是否存在 target - x
当我们使用遍历整个数组的方式寻找 target - x 时，需要注意到每一个位于 x 之前的元素都已经和 x 匹配过，因此不需要再进行匹配。而每一个元素不能被使用两次，所以我们只需要在 x 后面的元素中寻找 target - x

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        for i in range(0, len(nums)):
            for j in range(1, len(nums)):
                if target - nums[i] == nums[j] and i != j:
                    return i,j

注意到方法一的时间复杂度较高的原因是寻找 target - x 的时间复杂度过高。
因此，我们需要一种更优秀的方法，能够快速寻找数组中是否存在目标元素。如果存在，我们需要找出它的索引。
使用哈希表，可以将寻找 target - x 的时间复杂度降低到从O(N) 降低到O(1)。
这样我们创建一个哈希表(字典)，对于每一个 x，我们首先查询哈希表中是否存在 target - x，
然后将 x 插入到哈希表中，即可保证不会让 x 和自己匹配

class Solution:
        record = {}
        # 用enumerate方法直接把nums中值取到
        for index, val in enumerate(nums):
            if target - val not in record:
                record[val] = index#存在record中的是当前元素的下标
            else:
                return record[target-val], index

C++

class Solution {
public:
    vector twoSum(vector& nums, int target) {
        vector v(2);
        for(int i = 0; i < nums.size(); i++) {
            for(int j = i + 1; j < nums.size(); j++) {
                if(nums[i] + nums[j] == target) {
                    v[0] = i;
                    v[1] = j;
                }
            }
        }
        return v;
    }
};

C

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    static int a[2]={0};
    for(int i = 0;i

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