[LeetCode] Two Sum

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.

HashMap

Time Complexity
O(n) one pass 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.

思路

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.

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.

Reference: LeetCode Editorial Version

代码

public int[] twoSum(int[] nums, int target) {
    int[] res = new int[2];
    //corner case
    if(nums == null || nums.length < 2) return res;
    
    //key: the number, value: index
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    
    for(int i = 0; i < nums.length; i++){
        if(map.containsKey(target - nums[i])){
            res[0] = map.get(target- nums[i]);
            res[1] = i;
            return res;
        }else{
            map.put(nums[i], i);
        }
    }
    return res;
}