TwoSum

Question
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.

Example:
Given nums = [2, 7, 11, 15], target = 9,
Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].
UPDATE (2016/2/13):

The return format had been changed to zero-based indices. Please read the above updated description carefully.

Solution

Approach #1 (Brute Force) [Accepted]

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

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) [Accepted]

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]target−nums[i]) exists in the table. Beware that the complement must not be nums[i]nums[i] itself!

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) [Accepted]

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.

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)O(n). We traverse the list containing nn elements only once. Each look up in the table costs only O(1)O(1) time.
• Space complexity : O(n)O(n). The extra space required depends on the number of items stored in the hash table, which stores at most nn elements.
  HashMap 能够将数组元素查找时间复杂度从O(n)降至O(1)

other solutions:(in swift)

class Solution{
    func twoSum(_ nums: [Int], _ target: Int)->[Int]{
        var res:[Int] = [Int](count:2, repeatedValue:0)
        var numsCopy = nums
        quickSort(&numsCopy, 0,  numsCopy.count-1)
        var start:Int = 0
        var end:Int = numsCopy.count-1
        while start < end {
             if numsCopy[start] + numsCopy[end] == target {
                 break;
             }else if numsCopy[start] + numsCopy[end] < target {
                 start+=1
             }else {
                 end-=1
             }
        }
        var flag = 0
        for i in 0..<numsCopy.count{
            if nums[i] == numsCopy[start] && flag==0{
                res[0] = i
                flag = 1
            }
            if nums[i] == numsCopy[end] {
                res[1] = i
            }
        }
        return res
    }
    //quick sort
    func quickSort(inout array:[Int], _ startIndex:Int, _ endIndex:Int) {
        if startIndex < endIndex {
            let paititionIndex:Int = partition(&array, startIndex, endIndex)
            quickSort(&array, startIndex, paititionIndex-1)
            quickSort(&array, paititionIndex+1, endIndex)
        }
    }
    func partition(inout array:[Int], _ startIndex:Int, _ endIndex:Int) -> Int {
        var low = startIndex
        var high = endIndex
        let x = array[low]
        while low<high {
                while low<high && array[high]>=x {
                    high-=1
            }
            array[low] = array[high]
            while low<high &&  array[low]<=x{
                low+=1
            }
            array[high] = array[low]         
        }
        array[low] = x
        return low
    }
}

先将数组排序，然后根据target和 numsCopy[start] + numsCopy[end]大小关系，判断start前移（<target），还是end后退（>target），直至找到target == numsCopy[start] + numsCopy[end]。最后从原始数组中找到对应的下标。时间复杂度：快速排序$O(nlogn)+O(n)+O(n)$ 空间复杂度：$O(n)$，需要两倍数组内存