标签：速度   sam   遍历数组   array   range   条件   比较   shm   run   

Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

Solution

给定一个数组nums和一个目标值target，求数组中相加等于target的两个数的下标。一个预置条件是每一个target在数据中都只有一个解，并且一个元素不能被使用两次。

解法一

比较容易直接想到的是暴力遍历法：

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) {
                    return new int[]{i, j};
                }
            }
        }
        return new int[2];
    }
}

提交后得到的结果：

Python3版:

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

提交后得到的结果：

可以看到，Python相比较Java来说，运行速度确实慢很多。

上述的代码的想法就是利用i和j双重遍历数组，时间复杂度为O(n²)，空间复杂度为O(1)。

解法二

为了降低时间复杂度，我们用空间换时间。定义一个map。

Java版：

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

提交后得到的结果：

Python3版:

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = {}
        for i, num in enumerate(nums):
            diff = target - num
            if diff in d:
                return [d.get(diff), i]
            d[num] = i
        raise RuntimeError("No two sum solution")

提交后得到的结果：

可以看到用一个哈希map或者说是dict，可以大幅度节省时间，这是因为此时时间复杂变为了O(n)，空间复杂度也是O(n)

1. Two Sum

标签：速度   sam   遍历数组   array   range   条件   比较   shm   run   

原文地址：https://www.cnblogs.com/9plus/p/11421417.html