【leetcode-1】Two Sum

要求：

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

The function twoSum should return indices(index的复数，索引) 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

线索：

numbers[index1]+numbers[index2]=target

index1 < index2

代码：

---

解决方案一：暴力搜索

时间复杂度：O(n*n)——n*(n-1)/2

结果：Time Limit Exceeded

代码：

public class Solution {
     public int[] twoSum(int[] numbers, int target) {
          int[] index = new int[2];//int[] index=new int[]{1,2}    int[] index={1,2}
          for (index[0] = 0; index[0] < numbers.length - 1; index[0]++) {
               for (index[1] = index[0] + 1; index[1] < numbers.length; index[1]++) {
                    if (numbers[index[0]] + numbers[index[1]] == target)
                         break;
               }
          }
          return index;
     }
}

---

解决方案二：哈希查找

时间复杂度：O(n)——n+n

结果：Accepted

     

  public class Solution {
          public int[] twoSum(int[] numbers, int target) {
               int[] res = new int[2];
               Map map = new HashMap();
               for (int i = 0; i < numbers.length; i++) {
                    map.put(numbers[i], i);
               }
               for (int i = 0; i < numbers.length; i++) {
                    int gap = target - numbers[i];
                    if (map.get(gap) != null && (Integer)map.get(gap) != i) {
                         res[0] = i + 1;
                         res[1] = (Integer)map.get(gap) + 1;
                         break;
                    }
               }
               return res;
          }
     }

---

解决方案三：

public int[] twoSum(int[] numbers, int target) {
    int[] res=new int[2];
    if(numbers==null||numbers.length<2) return res;
    HashMap<Integer,ArrayList<Integer>> hm=new HashMap<Integer,ArrayList<Integer>>();
    for(int i=0;i<numbers.length;i++)
    {
        if(hm.containsKey(numbers[i]))
        {
            hm.get(numbers[i]).add(i);
        }
        else
        {
            ArrayList<Integer> indexArr=new ArrayList<Integer>();
            indexArr.add(i);
            hm.put(numbers[i],indexArr);
        }
    }
    for(int i=0;i<numbers.length;i++)
    {
        if(hm.containsKey(target-numbers[i]))
        {
            boolean isDouble=target==2*numbers[i];
            if(isDouble&&hm.get(numbers[i]).size()!=1)
            {
               res[0]=hm.get(numbers[i]).get(0)+1;
               res[1]=hm.get(numbers[i]).get(1)+1;
               break;
            }
            else if((!isDouble)&&hm.get(numbers[i]).size()==1)
            {
                res[0]=hm.get(numbers[i]).get(0)+1;
                res[1]=hm.get(target-numbers[i]).get(0)+1;
                break;
            }
        }
    }
    return res;
}

---

评语：

O (n2) runtime,  O (1) space – 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. As finding another value requires looping through the rest of array, its runtime complexity is  O(n2).

O (n) runtime,  O (n) space – Hash table:哈希表

We could reduce the runtime complexity of looking up a value to  O(1) using a hash map that maps a value to its index.

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

Average Rating: 4.5 (87 votes)

Is this solution helpful? Read  our book to learn more.