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