三種解決方法：
1、暴力法：遍歷每個num，查詢目標元素target-num

 class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        n = len(nums)
        for i in range(0,n):
            for j in range(i+1,n):
                if
 
 nums[j] == target - nums[i]:
                    return [i,j]

nums = [2, 7, 11, 15]
target = 9
twoSumExp = Solution()
print(twoSumExp.twoSum(nums, target))   

時間複雜度：O(n2)，其中，對於每個num，查詢目標元素target-num的複雜度為O(n)
空間複雜度：O(1)
2、兩次雜湊表法：第一次迴圈，建立陣列中值和索引的字典；第二次迴圈，從字典中找出target-num對應值。

class Solution:
    def
 
 twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        numsDict = {}
        n = len(nums)
        for i in range(0,n):
            numsDict[nums[i]] = i
        for j in range(0,1):
            num2 = target - nums[j]
            if
 
  num2 in nums and numsDict.get(num2)!=j:
                return [j,numsDict[num2]]

nums = [2, 7, 11, 15]
target = 9
twoSumExp = Solution()
print(twoSumExp.twoSum(nums, target))

時間複雜度：O(n)，雖然也將列表遍歷了兩遍，但是字典的查詢時間為O(1)
空間複雜度：O(n)，建立了一個雜湊表
降低了時間複雜度，增加了空間複雜度
3.一次雜湊表法：在建立陣列中值和索引的字典時，返回去檢查是否存在當前元素所對應的元素。

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        numsDict = {}
        n = len(nums)
        for i in range(0,n):
            numsDict[nums[i]] = i
            j = numsDict.get(target - nums[i],-1)
            if j != -1 and j != i:
                return [j,i]

nums = [2, 7, 11, 15]
target = 9
twoSumExp = Solution()
print(twoSumExp.twoSum(nums, target))

時間複雜度：O(n)，遍歷加查詢一次
空間複雜度：O(n)，建立一個雜湊表

補充知識：演算法複雜度*
演算法複雜度包括時間複雜度和空間複雜度。
1.演算法的時間複雜度
（1）定義：時間複雜度是指執行演算法所需要的計算工作量。一般，演算法的工作量用其執行的基本運算次數來度量，而演算法執行的基本運算次數是問題規模的函式。
（2）在同一個問題規模下，用平均性態和最壞情況來分析。一般情況下，用最壞情況的複雜度來分析演算法的時間複雜度。
（3）幾種常見時間複雜度
[1]常數階：執行次數與問題規模無關，執行時間恆定的演算法，稱為O(1）時間複雜度。一般順序結構和單純的分支結構（如if語句，不論真或假）執行次數不會隨問題規模變化，時間複雜度是O(1)；
[2]線性階：確定某個演算法的階次，需確定某個特定語句或某個特定語句塊執行的次數。演算法的階次的確定主要關注迴圈結構的執行情況。一般情況下，當單個for迴圈中迴圈條件與問題規模有關時，其時間複雜度為O(n)
[3]平方階：當巢狀的兩個for 迴圈中迴圈條件都與問題規模有關時，時間複雜度為O(2)。
如果外迴圈的迴圈次數改為m，則時間複雜度為O(m*n)。
即，迴圈的時間複雜度等於迴圈體的複雜度乘以該迴圈執行的次數。
[4]立方階：與線性階或平方階類似，立方階一般出現在三個for迴圈巢狀的迴圈中。但是，三個for迴圈巢狀，演算法的複雜度不一定為O(3)。
[5]對數階：時間複雜度為O( logn)
如下例，num乘上多少個2後能大於n,即2**x = n，則x = logn

num = 1
while num < n:
    num *= 2

常用時間複雜度所耗費的時間從大到小：
O(n**2)>O(nlogn)>O(n)>O(logn)>O(1)
(4)舉例說明：

for i in range(n):
    for j in range(i,n):
        pass

分析：當i=0時，內迴圈次數為n;當n=1時，內迴圈次數為n-1;…當n=n-1時，內迴圈次數為1.
則執行總次數為n +(n-1)+(n-2)+….1=(n(n+1))/2=(n^2/2)+n/2
只保留最高項；不考慮乘除因子
則，該演算法的複雜度為O(2)

2.演算法的空間複雜度
(1)定義：空間複雜度是指執行這個演算法所需要的記憶體空間。
(2)一般，可以建立一個新的輔助儲存結構，通過犧牲空間複雜度來換取時間複雜度。
(3) 一般情況下，執行程式時，除了需要儲存程式本身的指令、常數、變數和輸入資料外，還需要儲存對資料操作的儲存單元。若輸入資料所佔空間只取決於問題本身，和演算法無關，這樣只需要分析該演算法在實現時所需的輔助單元即可。若演算法執行時所需的輔助空間相對於輸入資料量是個常數，則稱此演算法的空間複雜度為0(1)。

                    歡迎批評指正！！！