leetcode_1_Two Sum

Description:

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:

Approach 1: Brute Force

The brute force approach is simple. Loop through each element x and find if there is another value that equals to target - x

方法1：蛮力

蛮力方法很简单。 遍历每个元素x并查找是否有另一个值等于target  -  x。

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[j] == target - nums[i])
                    return new int[] {i,j};
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

Complexity Analysis 复杂度分析

• Time complexity 时间复杂度: O(n^2). For each element, we try to find its complement by looping through the rest of array which takes O(n) time. Therefore, the time complexity is O(n^2).

• Space complexity 空间复杂度: O(1). 

 

 

Approach 2: Two-pass Hash Table

To improve our run time complexity, we need a more efficient way to check if the complement exists in the array. If the complement exists, we need to look up its index. What is the best way to maintain a mapping of each element in the array to its index? A hash table.

We reduce the look up time from O(n)to O(1) by trading space for speed. A hash table is built exactly for this purpose, it supports fast look up in near constant time. I say "near" because if a collision occurred, a look up could degenerate to O(n) time. But look up in hash table should be amortized O(1) time as long as the hash function was chosen carefully.

A simple implementation uses two iterations. In the first iteration, we add each element's value and its index to the table. Then, in the second iteration we check if each element's complement (target - nums[i]) exists in the table. Beware that the complement must not be nums[i] itself!

方法2：双通哈希表
为了提高运行时间的复杂性，我们需要一种更有效的方法来检查数组中是否存在补码。 如果存在补充，我们需要查找其索引。 维护数组中每个元素到其索引的映射的最佳方法是什么？ 哈希表。

我们通过交换空间来减少从O（n）到 O（1）的查找时间。 哈希表就是为此目的而构建的，它支持在接近恒定的时间内快速查找。 我说“接近”因为如果发生碰撞，查找可能会退化为O（n）时间。 但是只要仔细选择哈希函数，查找哈希表就应该分摊O（1）时间。

一个简单的实现使用两次迭代。 在第一次迭代中，我们将每个元素的值及其索引添加到表中。 然后，在第二次迭代中，我们检查表中是否存在每个元素的补码（target-nums [i] ）。 请注意，补充不能是nums [i] 本身！

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");
}

Complexity Analysis 复杂度分析:

• Time complexity : O(n). We traverse the list containing n elements exactly twice. Since the hash table reduces the look up time to O(1), the time complexity is O(n).

• Space complexity : O(n). The extra space required depends on the number of items stored in the hash table, which stores exactly n elements. 

Approach 3: One-pass Hash Table

It turns out we can do it in one-pass. While we iterate and inserting elements into the table, we also look back to check if current element's complement already exists in the table. If it exists, we have found a solution and return immediately.

方法3：一通哈希表

事实证明我们可以一次通过。 当我们迭代并将元素插入表中时，我们还会回顾检查表中是否已存在当前元素的补码。 如果存在，我们找到了解决方案并立即返回。

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");
}

Complexity Analysis 复杂度分析:

• Time complexity : O(n). We traverse the list containing n elements only once. Each look up in the table costs only O(1) time.

• Space complexity : O(n). The extra space required depends on the number of items stored in the hash table, which stores at most n elements.