領釦-1 兩數之和 Two Sum

目錄

兩數之和 Two Sum

題目

給定一個整數陣列 nums 和一個目標值 target，請你在該陣列中找出和為目標值的那 兩個 整數，並返回他們的陣列下標。
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

示例:

給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

方法宣告：

class Solution {
    public int[] twoSum(int[] nums, int target) {

    }
}

方法一：暴力法

暴力法很簡單。遍歷每個元素 x，並查詢是否存在一個值與 target−x 相等的目標元素。

class Solution {
    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[i] + nums[j] == target) {
                    return new int[] { i, j };
                }
            }
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}
 

時間複雜度：O(n^2)， 對於每個元素，我們試圖通過遍歷陣列的其餘部分來尋找它所對應的目標元素，這將耗費 O(n) 的時間。因此時間複雜度為 O(n^2)
空間複雜度：O(1)

方法二：兩遍雜湊表

為了對執行時間複雜度進行優化，我們需要一種更有效的方法來檢查陣列中是否存在目標元素。如果存在，我們需要找出它的索引。保持陣列中的每個元素與其索引相互對應的最好方法是什麼？雜湊表。

通過以空間換取速度的方式，我們可以將查詢時間從 O(n) 降低到 O(1)。雜湊表正是為此目的而構建的，它支援以 近似 恆定的時間進行快速查詢。我用“近似”來描述，是因為一旦出現衝突，查詢用時可能會退化到 O(n)。但只要你仔細地挑選雜湊函式，在雜湊表中進行查詢的用時應當被攤銷為 O(1)。

一個簡單的實現使用了兩次迭代。在第一次迭代中，我們將每個元素的值和它的索引新增到表中。然後，在第二次迭代中，我們將檢查每個元素所對應的目標元素target−nums[i]是否存在於表中。注意，該目標元素不能是 nums[i] 本身！

class Solution {
    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");
    }
}

時間複雜度：O(n)， 我們把包含有 n 個元素的列表遍歷兩次。由於雜湊表將查詢時間縮短到 O(1) ，所以時間複雜度為 O(n)。
空間複雜度：O(n)， 所需的額外空間取決於雜湊表中儲存的元素數量，該表中儲存了 n 個元素。

方法三：一遍雜湊表

事實證明，我們可以一次完成。在進行迭代並將元素插入到表中的同時，我們還會回過頭來檢查表中是否已經存在當前元素所對應的目標元素。如果它存在，那我們已經找到了對應解，並立即將其返回。

class Solution {
    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");
    }
}

時間複雜度：O(n)， 我們只遍歷了包含有 n 個元素的列表一次。在表中進行的每次查詢只花費 O(1) 的時間。
空間複雜度：O(n)， 所需的額外空間取決於雜湊表中儲存的元素數量，該表最多需要儲存 n 個元素。

其他方式

PS：此方式在 target 為兩個值相同的元素的和時會出現問題，例如 nums = [3 ,3]，target = 6。因為 HashMap 的 key 為元素的值，當具有相同值的元素第二次出現時，新增到 HashMap 會失敗，所以會導致找不到此元素。

class Solution {
    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);
            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");
    }
}

2018-12-6