題目描述

給定一個整數陣列和一個目標值，找出陣列中和為目標值的兩個數。

你可以假設每個輸入只對應一種答案，且同樣的元素不能被重複利用。

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 element twice.

示例:

給定 nums = [2, 7, 11, 15], target = 9

因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
 

解決方案

方法一：暴力法

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

Java程式碼

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

Python程式碼

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        nums_len=
 
len(nums)
        for i in range(0,nums_len):
            num1=nums[i]
            for j in range(i+1,nums_len):
                num2=nums[j]
                if num1+num2==target:
                    return [i,j]
        return "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]$本身！

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);
    }
    //每次迴圈用目標值減去當前迴圈的值，然後將餘下的值再map集合中去尋找（不重合）
    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");
}

python程式碼

class Solution:	
    def twoSum(self,nums,target):
		k_v={}
		nums_len=len(nums)
		for i in range(nums_len):
			k_v[nums[i]]=i
		for i in range(nums_len):
			temp = target-nums[i]
			#字典值的獲取
			if(temp in k_v.keys() and i!=k_v.get(temp)):
				return [i,k_v[temp]]
		return "No two sum 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");
}

python程式碼

class Solution:
	def twoSum3(self,nums,target):
		k_v={}
		for i in range(len(nums)):
			temp = target-nums[i]
			if temp in k_v.keys():
				return [k_v.get(temp),i]
			k_v[nums[i]]=i
		return "No two sum solution"

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

三種方法執行時間對比

在python實現下，三個程式執行時間對比（單位：s）

測試程式

import time
#建立一個物件
class Solution:
	def twoSum(self,nums,target):
		nums_len=len(nums)
		for i in range(0,nums_len):
			num1=nums[i]
			for j in range(i+1,nums_len):
				num2=nums[j]
				if num1+num2==target:
					return [i,j]
		return "No two sum solution"
	def twoSum2(self,nums,target):
		k_v={}
		nums_len=len(nums)
		for i in range(nums_len):
			k_v[nums[i]]=i
		for i in range(nums_len):
			temp = target-nums[i]
			#字典值的獲取
			if(temp in k_v.keys() and i!=k_v.get(temp)):
				return [i,k_v[temp]]
		return "No two sum solution"
	def twoSum3(self,nums,target):
		k_v={}
		for i in range(len(nums)):
			temp = target-nums[i]
			if temp in k_v.keys():
				return [k_v.get(temp),i]
			k_v[nums[i]]=i
		return "No two sum solution"
#建立物件
s1=Solution()
nums=[3,2,4]
target=6
start=time.clock()
print("方法一執行結果：{0}；執行時間：{1}".format(s1.twoSum(nums, target),time.clock()-start))
start=time.clock()
print("方法二執行結果：{0}；執行時間：{1}".format(s1.twoSum2(nums, target),time.clock()-start))
start=time.clock()
print("方法三執行結果：{0}；執行時間：{1}".format(s1.twoSum3(nums, target),time.clock()-start))

測試結果