LeetCode分类：查找二

最新推荐文章于 2022-06-16 13:50:43 发布

yq313210

最新推荐文章于 2022-06-16 13:50:43 发布

阅读量371

点赞数

分类专栏： LeetCode 文章标签：数据结构 leetcode 算法 python

本文链接：https://blog.youkuaiyun.com/yq313210/article/details/108287222

版权

LeetCode 专栏收录该内容

4 篇文章

订阅专栏

本文详细介绍了LeetCode中关于查找的实战案例，包括两数之和、三数之和、四数之和、字母异位词分组以及重复元素II等问题的解题思路和高效算法，涉及排序、双指针、哈希表等技术。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

查找实战

案例一：两数之和

题目描述： 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。
示例：

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

解题思路： 首先想到暴力解决，即第一遍遍历数组，第二遍遍历当前遍历值之后的元素，但是时间复杂度为O(n^2)。
于是想着优化，用二分查找法，先将输入数组进行排序(从小到大)，但是这样元素的索引也会发生变化，于是在排序前先使用一个额外的数组拷贝一份原来的数组，对于两个相同元素的索引问题，使用一个bool型变量辅助将两个索引都找到，总的时间复杂度为O(n)+O(nlogn) = O(nlogn)
代码如下：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        record = dict()
        nums_copy = nums.copy()
        sameFlag = True;
        nums.sort()
        l,r = 0,len(nums)-1
        while l < r:
            if nums[l] + nums[r] == target:
                break
            elif nums[l] + nums[r] < target:
                l += 1
            else:
                r -= 1
        res = []
        for i in range(len(nums)):
            if nums_copy[i] == nums[l] and sameFlag:
                res.append(i)
                sameFlag = False
            elif nums_copy[i] == nums[r]:
                res.append(i)
        return res

但是还有另外一种更方便的解法，通过list(enumerate(nums))开始实现下标和值的绑定，不用专门的再copy加bool判断。
代码如下：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        # res = dict()
        # for index in range(len(nums)):
        #     res[nums[index]] = index
        # for i,num in enumerate(nums):
        #     j = res.get(target-num)
        #     if j is not None and j!=i:
        #         return [i,j]
        nums = list(enumerate(nums))
       

        nums.sort(key =lambda x:x[1])
        print(nums)
        l = 0
        r = len(nums)-1
        while l<r:
            if nums[l][1]+nums[r][1] == target:
                return [nums[l][0],nums[r][0]]
            elif nums[l][1]+nums[r][1] < target:
                l +=1
            else:
                r -=1

案例二：三数之和

题目描述： 给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例：

给定数组 nums = [-1, 0, 1, 2, -1, -4]，

满足要求的三元组集合为：
[
[-1, 0, 1],
[-1, -1, 2]
]

解题思路： 不考虑暴力求解，因此还是二分的思想。主要是排序+双指针法。一个难点就是避免重复解。

算法流程：

特判，对于数组长度 n，如果数组为 null 或者数组长度小于 3，返回 []。
对数组进行排序。
遍历排序后数组。

若 nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 00，直接返回结果。
对于重复元素：跳过，避免出现重复解
令左指针 L=i+1，右指针 R=n-1，当 L<R时，执行循环：
(1) 当nums[i]+nums[L]+nums[R]==0 ，执行循环，判断
(2)左界和右界是否和下一位置重复，去除重复解。并同时将 L,R 移到下一位置，寻找新的解
若和大于 0，说明 nums[R]太大，R 左移
若和小于 0，说明 nums[L] 太小，L右移

复杂度分析：

时间复杂度：O(n^2) ，其中数组排序O(nlogn),遍历数组O(n),双指针遍历也是O(n),故时间复杂度计算：O(nlogn) + O(n)*O(n),即O(n^2).
空间复杂度O(1)
代码如下：

class Solution(object):
    def threeSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[List[int]]
        """
        nums.sort()
        res = []
        print(nums)
        n = len(nums)
        if not nums or n<3:
            return res
        
        

        for i in range(n):
            if nums[i]>0:
                return res
            if i>0 and nums[i] ==nums[i-1]:
                continue
            l = i+1
            r = n-1
        
            

            while l<r:
                if  nums[i]+nums[l]+nums[r]==0:
                    res.append([nums[i],nums[l],nums[r]])
                    while l<r and nums[l] == nums[l+1]:
                        l+=1
                    while l<r and  nums[r] == nums[r-1]:
                        r-=1
                    l+=1
                    r-=1
                elif nums[i]+nums[l]+nums[r]>0:
                    r-=1
                else:
                    l+=1
        
        return res

案例三：三数之和

题目描述: 给定一个包括 n 个整数的数组 nums 和一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例：
输入：nums = [-1,2,1,-4], target = 1
输出：2
解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。

提示：

3 <= nums.length <= 10^3
10^3 <= nums[i] <= 10^3
10^4 <= target <= 10^4

解题思路： 此题跟案例二类似，唯一不同的是target不确定，因此需要使用一个临时变量存储当前最合适的target。主要思想也是使用排序+双指针法。

算法流程

首先进行数组排序，时间复杂度 O(nlogn)
在数组 nums 中，进行遍历，每遍历一个值利用其下标i，形成一个固定值 num[i]
再使用前指针指向 start = i + 1 处，后指针指向 end = nums.length - 1处，也就是结尾处
根据 sum = nums[i] + nums[start] + nums[end]的结果，判断 sum与目标 target的距离，如果更近则更新结果ans
同时判断 sum与 target 的大小关系，因为数组有序，如果sum > target 则 end--，如果sum < target 则start++ ，如果sum == target 则说明距离为0 直接返回结果
整个遍历过程，固定值为 n次，双指针为 n次，时间复杂度为O(n^2)
总时间复杂度：O(nlogn) + O(n^2) = O(n^2)

代码如下：

class Solution(object):
    def threeSumClosest(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        n = len(nums) 
        re = float("inf")
        if n<3 or not nums:
            return None
        
        nums.sort()
        print(nums)
        
        for i in range(n):
            if i>0 and nums[i]==nums[i-1]:
                continue
            s = i+1
            e = n-1
            while s<e:
                cur = nums[i]+nums[s]+nums[e]
                
                if abs(cur-target)<=abs(re-target):
                    re = cur
                if cur>target:
                    e-=1
                else:
                    s+=1
        return re

案例四：四数之和

题目描述： 给定一个包含 n 个整数的数组 nums 和一个目标值 target，判断 nums 中是否存在四个元素 a，b，c 和 d ，使得 a + b + c + d 的值与 target 相等？找出所有满足条件且不重复的四元组。

示例
给定数组 nums = [1, 0, -1, 0, -2, 2]，和 target = 0。
满足要求的四元组集合为：
[
[-1, 0, 0, 1],
[-2, -1, 1, 2],
[-2, 0, 0, 2]
]

解题思路： 四数之和与前面三数之和的思路几乎是一样的，主要思想还是排序+双指针法，但是此题需要两个循环。算法流程如下：

首先进行数组排序，时间复杂度 O(nlogn)
在数组 nums 中，进行遍历，每遍历一个值利用其下标i，形成一个固定值 num[i]，在此循环下从i+1开始继续遍历，形成固定值num[j]。到此相当于是双重循环
再使用前指针指向 start = j+ 1 处，后指针指向 end = nums.length - 1处，也就是结尾处
根据 sum = nums[i] + num[j] + nums[start] + nums[end]的结果，判断 sum与目标 target是否相等，如果相等将四元组添加到结果中。
同时判断 sum与 target 的大小关系，因为数组有序，如果sum > target 则 end--，如果sum < target 则start++
整个遍历过程，循环为 n^2次，双指针为 n次，时间复杂度为O(n^3)
总时间复杂度：O(nlogn) + O(n^3) = O(n^3)

代码如下：

class Solution(object):
    def fourSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[List[int]]
        """
        res = []
        nums.sort()
        if not nums or len(nums)<4:
            return res

        for i in range(len(nums)-3):
            if i>0 and nums[i] == nums[i-1]:
                continue
            for j in range(i+1,len(nums)-2):
                if j >i+1 and nums[j]==nums[j-1]:
                    continue
                l = j+1
                r = len(nums)-1
                while l<r:
                    if nums[i]+nums[j]+nums[l]+nums[r] ==target:
                        res.append([nums[i],nums[j],nums[l],nums[r]])
                        while l<r and nums[l]==nums[l+1]:
                            l+=1
                        while l<r and nums[r] == nums[r-1]:
                            r-=1
                    
                    if (nums[i]+nums[j]+nums[l]+nums[r])<target:
                        l+=1
                    else:
                        r-=1
        return res

案例五：字母异位词分组

题目描述： 给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例
输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

解题思路： 用字典解决，其形式为
{(u'a', u'b', u't'): [u'bat'], (u'a', u'e', u't'): [u'eat', u'tea', u'ate'], (u'a', u'n', u't'): [u'tan', u'nat']}，也是对数组的元素进行排序。
代码如下：

class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        dic = {}
        for s in strs:
            #print (sorted(s))
            #print(dic.get(tuple(sorted(s)), [])+[s])
           
            
            dic[tuple(sorted(s))] = dic.get(tuple(sorted(s)), []) + [s]
            #print(dic)
        return dic.values()

时间复杂度为O(n)

案例六：重复元素II

题目描述： 给定一个整数数组和一个整数 k，判断数组中是否存在两个不同的索引i 和 j，使得 nums [i] = nums [j]，并且i和j 的差的 绝对值 至多为 k。

示例
输入: nums = [1,2,3,1], k = 3
输出: true

输入: nums = [1,0,1,1], k = 1
输出: true

输入: nums = [1,2,3,1,2,3], k = 2
输出: false

解题思路： 用哈希

维护一个哈希表，里面始终最多包含 k 个元素，当出现重复值时则说明在 k 距离内存在重复元素
每次遍历一个元素则将其加入哈希表中，如果哈希表的大小大于 k，则移除最前面的数字
时间复杂度：O(n)，n为数组长度

代码如下：

class Solution(object):
    def containsNearbyDuplicate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: bool
        """
        if not nums or len(nums)<2:
            return False
        
        s = set()
        for i in range(len(nums)):
            if nums[i] in s:
                return True
            
            s.add(nums[i])
        
            if len(s)>k:
                s.remove(nums[i-k])
        return False