LeetCode两数之和Swift

给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。

示例:

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

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

暴力法（时间复杂度O(n2)，空间复杂度O(1)）

class Solution {
    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
        for i in 0...(nums.count - 1) {
            for j in (i + 1)...(nums.count - 1) {
                if nums[j] == target - nums[i]  {
                    return [i, j];
                }
            }
        }
        return []
    }
}

如果传入的数组元素值各不相同，可以进行以下优化，以空间换时间（时间复杂度O(n)，空间复杂度O(n)）

class Solution {
    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
        var dict = Dictionary<Int,Int>()
        var i = 0;
        for n in nums {//遍历数组将每一项数组值作为key，对应的数组下标作为value添加到字典里
            dict[n] = i
            i = i+1
        }
        var arr = [-1,-1]
        
        var j = 0;
        for n in nums {//遍历数组，直接在上述字典中依次查找key为（target - n）的value,找到此value且与j值不同，即为答案
            if dict.keys.contains(target - n) && j != dict[target - n]
            {
                arr[0] = j
                arr[1] = dict[target - n] ?? -1
                return arr
            }
            j = j+1
        }
        return arr
    }
}

 以空间换时间（时间复杂度O(n)，空间复杂度O(n)）

class Solution {
    func twoSum(_ nums: [Int], _ target: Int) -> [Int] {
        var result = [Int]()
        var container = Set<Int>()
        for (index, value) in nums.enumerated() {
            let match = target - value
            if container.contains(match) {
                let first  = nums.firstIndex(of: match)!
                result.append(first)
                result.append(index)
                break
            }
            container.insert(value)
        }
        return result
    }
}