再忙也别忘了 LeetCode_01 两数之和

Horizon John

已于 2024-08-05 02:29:05 修改

阅读量297

点赞数 1

文章标签： leetcode 算法动态规划

于 2022-01-02 20:48:03 首次发布

本文链接：https://blog.csdn.net/weixin_45084253/article/details/122279915

版权

再忙也别忘了 LeetCode 专栏收录该内容

4 篇文章 13 订阅

订阅专栏

本文介绍了LeetCode中经典问题‘两数之和’的三种解法，包括双重循环、改进的线性搜索以及哈希表解决方案。重点讨论了哈希表如何实现O(n)时间复杂度的高效查找，从而超越O(n²)的算法，成为最佳实践。此外，还分析了Python中字典操作的时间复杂度。

摘要由CSDN通过智能技术生成

第一题：两数之和

通过率 ：52.2%
难度：简单 [ ⭐ ✩ ✩ ✩ ✩ ]
相关标签 ：数组 哈希表
题目链接 🔗 ：1. 两数之和

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

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

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

示例1：

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

示例2：

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

示例3：

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

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109

只会存在一个有效答案！

进阶：你可以想出一个时间复杂度小于 O(n²) 的算法吗？

解题（Python）

方法一：

首先想到的解题方法是，利用双重循环 i 和 j，其中 j = i+1，遍历两次数组，直到找到 nums[i] + nums[j] = target ，然后返回 i 和 j

这样做的虽然很简单但是时间复杂度为 O(n²) ，空间复杂度为 O(1)

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

运行结果：
在这里插入图片描述

方法二：

使用 i 遍历一次数组，在遍历过程中再去判断数组 nums 里面是否存在 target-nums[i] ，且 index[ target-nums[i] ] ≠ i ，此时输出对应的 i 和 target-nums[i]的 index 值

这样做的时间复杂度为 O(n²)，空间复杂度为 O(1)

class Solution:
    def twoSum(self, nums, target):
        '''
        rtype:       List[int]
        type nums:   List[int]
        type target:   int
        '''
        for i in range(len(nums)):
            if target-nums[i] in nums:
                if i!=nums.index(target-nums[i]):
                    return [i, nums.index(target-nums[i])]                    
        return [ ]

运行结果：
在这里插入图片描述

方法三：

利用 哈希表 的方法，创建一个空字典 hashmap ，使用 i 遍历一次数组，在遍历过程中再去判断字典 hashmap 里面是否存在 target-nums[i] ，若存在返回该 value 对应的 key 值，若不存在，则将 nums[i] 存入字典 hashmap 中

这样做的时间复杂度为 O(n) ，空间复杂度为 O(n)

class Solution:
    def twoSum(self, nums, target):
        '''
        rtype:       List[int]
        type nums:   List[int]
        type target:   int
        '''
        hashmap = {}
        for i in range(len(nums)): 
            if target - nums[i] in hashmap:
                return [hashmap[target - nums[i]], i]
            else:
                hashmap[nums[i]] = i
        return [ ]