leetcode--001--两数之和

难度: Easy
题目链接：https://leetcode-cn.com/problems/two-sum/

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

思路1：时间复杂度: O(N^2) 空间复杂度: O(1)

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        # 第一轮遍历
        for i in range(len(nums)):
            # 第二轮遍历不能重复计算了
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    # 注意 leetcode 中要求返回的是索引位置
                    return [i, j]

Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        // 第一轮遍历
        for (int i = 0; i < nums.length; i++) {
            // 第二轮遍历不能重复计算了
            for (int j = i + 1; j < nums.length; j++) {
                if (nums[i] + nums[j] == target) {
                    // 注意 leetcode 中要求返回的是索引位置
                    return new int[]{i, j};
                }
            }
        }
        return null;
    }
}

C++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int n = nums.size();
        // 第一轮遍历
        for (int i = 0;i < n;i++) {
            // 第二轮遍历不能重复计算了
            for (int j = i + 1;j < n;j++) {
                if (nums[i] + nums[j] == target) {
                    // 注意 leetcode 中要求返回的是索引位置
                    vector<int> ret(2);
                    ret[0] = i;
                    ret[1] = j;
                    return ret;
                }
            }
        }
        return vector<int>(0);
    }
};

思路2：时间复杂度: O(N) 空间复杂度: O(N)

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lookup = {}
        for i, num in enumerate(nums):
            if target - num in lookup:
                return [lookup[target-num], i]
            else: # 每一轮都存下当前num和其index到map中
                lookup[num] = i

Java

class Solution {
    public int[] twoSum(int[] nums, int target) {
        HashMap<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            // 将原本为两个目标值切换为一个目标值，只需要每次从 map 中寻找目标值即可
            int num = target - nums[i];
            if (map.containsKey(num)) {
                return new int[]{map.get(num), i};
            }
            // 每次遍历过的值都存储到 map 中，这样之后就能从 map 中寻找需要的目标值
            map.put(nums[i], i);
        }
        return null;
    }
}

C++

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> indexMap;
        unordered_map<int, int>::iterator it;
        for (int i = 0;i < nums.size();i++) {
            it = indexMap.find(target - nums[i]);
            if (it != indexMap.end()) {
                vector<int> ret(2);
                ret[0] = it->second;
                ret[1] = i;
                return ret;
            } else { // 每一轮都存下当前num和其index到map中
                indexMap[nums[i]] = i;
            }
        }
        return vector<int>(0);
    }
};