算法系列–学习记录

【leetcode-01-两数之和】–python解法

题目：

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

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

输入：nums = [3,3], target = 6
输出：[0,1]

解法一：

class Solution(object):
    '''
    解法一：暴力枚举
    枚举列表中的每一个元素与除去自己以外的每一个元素相加，与target进行比较
    '''
    def twoSum(self, nums, target):
        # 枚举第一个整数的下标
        for i in range(len(nums)):
            # 枚举第二个整数的下标。注意：要除去i这个元素，题目要求->数组中同一个元素在答案里不能重复出现
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] == target:
                    # 与target相等，返回下标结果
                    return [i, j]
        # 不存在结果,返回空列表
        return []

'''
算法效率：
时间复杂度:O(N²).N为数组中的元素,最坏的情况就是数组中任意两个元素都要被匹配一次
空间复杂度：O(1).这里只有一个变量就是返回结果的列表，所以是常数个变量。
'''

解法二：

class Solution(object):
    '''
    解法二：单次循环
    暴力枚举时间复杂度高的原因：寻找第二个下标也是O(N)的，
    '''
    def twoSum(self, nums, target):
        # 枚举第一个下标
        for i in range(len(nums)):
            # 计算出另一个数的值
            res = target - nums[i]
            # 判断是否存在列表 todo 注意:需要从i+1开始判断，题目要求数组中同一个元素在答案里不能重复出现
            if res in nums[i+1:]:
                # 如果存在就返回 todo 注意：取第二个数下标也是从i+1开始，去完之后要加上i+1，因为要与nums下标对应
                return [i, nums[i+1:].index(res)+(i+1)]
        return []

'''
算法效率
时间复杂度:O(N).N为数组中的元素,对于每一个元素，可以O(1)的取寻找 target - num[i]
空间复杂度：O(1).这里只有一个变量就是返回结果的列表，所以是常数个变量。
'''

解法三：

class Solution03(object):
    '''
    解法三：哈希表
    基于解法二使用哈希表
    '''

    def twoSum(self, nums, target):
        # 创建哈希表
        hash_dict = {}
        # 枚举元素
        for i, num in enumerate(nums):
            # 判断target-num是否存在hash_dict
            if target - num in hash_dict:
                # 值存在dict,返回列表
                return [hash_dict[target - num], i]
            # 不存在就将 num插入dict,就可保证不会让值与自己匹配
            hash_dict[nums[i]] = i
        return []
'''
时间复杂度:O(N).N为数组中的元素,对于每一个元素，可以O(1)的取寻找 target - num[i]
空间复杂度：O(N).主要是哈希表的开销
'''

解法四：

class Solution(object):
    '''
    解法四：相向双指针
    '''
    def twoSum(self, nums, target):
        # 排序会打乱原本的下标,所以复制列表
        nums_copy = nums.copy()
        nums_copy.sort()
        n = len(nums_copy)
        left = 0
        right = n - 1
        # 保证同一个元素不重复
        while left < right:
            res = nums_copy[left] + nums_copy[right]
            # 优化
            # 最小的两个值相加大于目标值,结束
            if nums_copy[0] + nums_copy[1] > target:
                break
            # 最大的两个数相加小于目标值,结束
            if nums_copy[-1] + nums_copy[-2] < target:
                break
            if res == target:
                # 通过值来获取nums对应的下标
                index01 = nums.index(nums_copy[left])
                index02 = nums.index(nums_copy[right])
                # 当下标一样时,说明两个整数是一样的,要进行处理
                if index01 == index02:
                    # 除去第一个元素对应的值,那么就只剩下另一个下标对应的值了
                    nums.pop(index01)
                    # 重新获取第二个下标 注意因为去除了一个值,所以下标要+1
                    index02 = nums.index(nums_copy[right]) + 1
                return [index01, index02]
            # 最小 + 最大 > 目标值,说明最大太大,向左移位
            if res > target:
                right -= 1
            # 最小 + 最大 < 目标值,说明最小太小,向右移位
            elif res < target:
                left += 1
        return []
'''
时间复杂度:O(N).
空间复杂度：O(1).就只有几个额外的变量
'''