Two Sum

1. Question

给一整数数组，找两个数，使其和正好是给定值。函数 twoSum应当返回两个数的索引，且index1小于index2。索引不是从0开始的。

假设每个输入都正好有一个解。

Given an array of integers, find two numbers such that they add up to a specific target number.

The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.

You may assume that each input would have exactly one solution.

Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2

2. Solution

最优方案时间复杂度O(n)

2.1 O(n2) solution

用两个循环遍历所有数对，找到符合要求的。

2.2 O(nlogn) solution

方案一：采用二叉搜索

1. 数组按升序排序（采用map存储数组值和索引）
2. 遍历数组，假设每个值是两个数的其中一个值，采用二叉搜索查找另一个值。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Map.Entry;
import java.util.HashMap;

public class Solution {
    public int[] twoSum( int[] numbers, int target ){
        HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
        for( int k=0; k<numbers.length; k++ )
            map.put(k,numbers[k]);
        //sort by num value, nlog(n) time
        ArrayList<Entry<Integer,Integer>> num = new ArrayList<Entry<Integer,Integer>>( map.entrySet() );
        Comparator<Entry<Integer,Integer>> comp =  new Comparator<Entry<Integer,Integer>>(){
            public int compare( Entry<Integer,Integer> e1, Entry<Integer,Integer> e2 ){
                return e1.getValue() - e2.getValue();
            }
        };
        Collections.sort( num, comp);
        
        //get the sorted array, n time
        int[] sorted = new int[numbers.length];
        for( int k=0; k<numbers.length; k++ )
            sorted[k] = num.get(k).getValue().intValue();
        
        //find twoSum from the sorted array, using binary search, nlog(n) time
        int mid = target/2;
        if( sorted[numbers.length-1]< mid ) return null;
        int i;
        for( i=0; sorted[i]<mid; i++ );
        if( sorted[i] > mid )
            i--;
        int index1;
        int index2;
        for( index1=0; index1<=i; index1++ ){
            index2 = Arrays.binarySearch( sorted, i+1, sorted.length, target - sorted[index1] );
            if( index2 >0 ){
                index1 = num.get(index1).getKey()+1;
                index2 = num.get(index2).getKey()+1;
                if( index1 < index2 )
                    return new int[] { index1, index2 };
                else
                    return new int[] { index2, index1 };
            }
        }
        return null;
    }
}

方案二：采用双指针

1. 数组按升序排序（注意索引）
2. 采用双指针，一个指针head指向数组头，一个指针tail指向数组尾。判断num[head]+num[tail]：
   1. 如果和小与给定值，head++（向和增大的方向移动指针）
   2. 如果和大于给定值，tail--（向和减小的方向移动指针）
   3. 如果和等于给定值，返回相应的索引值，按要求返回。

import java.util.Arrays;


public class Solution {
        public int[] twoSum( int[] numbers, int target ){
        //if and only if there are two same numbers which sum to target, for the result, there is no duplicates in the array.
        int[] sNum = numbers.clone();
        Arrays.sort(sNum);
        
        int mid = target / 2;
        if( sNum[sNum.length-1] < mid )    return null;
        
        int index1 = 0;
        int index2 = sNum.length-1;
        while( index1 < index2 ){
            int sum = sNum[index1] + sNum[index2];
            if( sum==target ){
                for( int k=0; k<numbers.length; k++ ){
                    if( sNum[index1] == numbers[k] ){
                        index1 = k;
                        break;
                    }                    
                }
                for( int k = numbers.length-1; k>=0;  k-- ){
                    if( sNum[index2] == numbers[k] ){
                        index2 = k;
                        break;
                    }
                }
                if( index1 > index2 ){
                    int temp = index1;
                    index1 = index2;
                    index2 = temp;
                }
                return new int[] { index1+1, index2+1 };
            }
            if( sum < target )
                index1++;
            else
                index2--;
        }
        
        return null;
    }
}

2.3 O(n) solution

采用map保存数组，数值为键，索引为值。遍历数组，如果不在map中，加入map。考察map中是否存在满足num[i]要求的数。

该方法对数组中的每个数都找是否有符合要求的另一个数，因此不会有遗漏（这是最符合人的思路的方法）。且由于采用map，找的时间为常数时间，从而算法时间复杂度O(n).

import java.util.Hashtable;


public class Solution {
    //when using map structure, we don't need to sort the array
    public int[] twoSum( int[] numbers, int target ){
        Hashtable< Integer, Integer > num = new Hashtable< Integer, Integer >();
        for( int i=0; i< numbers.length; i++ ){
            if( num.get( numbers[i]) == null )
                num.put(numbers[i], i);
            Integer j = num.get( target - numbers[i]);
            if( j!=null && j < i )
                return new int[] { j.intValue()+1, i+1 };
        }
        return null;
    }
}