【数据结构面试刷题】 存在重复元素类

数据结构刷题

1 存在重复元素

1.3

O(n)神仙解法，桶，参考自https://leetcode.com/problems/contains-duplicate-iii/discuss/339421/Python-bucket-method-in-detail

首先，定义桶的大小是t+1, nums[i]//(t+1)决定放入几号桶,这样在一个桶里面的任意两个的绝对值差值都<=t
例如t=3, nums=[0 ,5, 1, 9, 3,4],那么0号桶就有[0,1,3],1号桶就有[4,5],2号桶就有[9]

先不考虑索引差值最大为K的限制，那么遍历nums每一个元素，并把他们放入相应的桶中，有两种情况会返回True

要放入的桶中已经有其他元素了，这时将nums[i]放进去满足差值<=t
可能存在前面一个桶的元素并且与nums[i]的差值<=t 或者 存在后面一个桶的元素并且与nums[i]的差值<=t
根据返回True的第一个条件，可以知道前后桶的元素最多也只能有一个。

接着考虑限制桶中的索引差最大为K,当i>=k的时候：
我们就要去删除存放着nums[i-k]的那个桶(编号为nums[i-k]//(t+1))
这样就能保证遍历到第i+1个元素时，全部桶中元素的索引最小值是i-k+1，就满足题目对索引的限制了

class Solution:
    def containsNearbyAlmostDuplicate(self, nums: List[int], k: int, t: int) -> bool:
        if t < 0 or k < 0:
            return False
        all_buckets = {}
        bucket_size = t + 1                     # 桶的大小设成t+1更加方便
        for i in range(len(nums)):
            bucket_num = nums[i] // bucket_size # 放入哪个桶
            
            if bucket_num in all_buckets:       # 桶中已经有元素了
                return True
            
            all_buckets[bucket_num] = nums[i]   # 把nums[i]放入桶中
            
            if (bucket_num - 1) in all_buckets and abs(all_buckets[bucket_num - 1] - nums[i]) <= t: # 检查前一个桶
                return True
            
            if (bucket_num + 1) in all_buckets and abs(all_buckets[bucket_num + 1] - nums[i]) <= t: # 检查后一个桶
                return True
            
            # 如果不构成返回条件，那么当i >= k 的时候就要删除旧桶了，以维持桶中的元素索引跟下一个i+1索引只差不超过k
            if i >= k:
                all_buckets.pop(nums[i-k]//bucket_size)
                
        return False

1.2

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

# 哈希
# 初试化哈希表hash= \{\}hash={}

# 遍历数组：

# 若nums[i]nums[i]不在hashhash中，则令nums[i]nums[i]为key，value为当前的索引ii。
# 若已存在：
# 判断当前的索引和上一相同元素的索引差是否小于等于kk，即i-hash[nums[i]]<=ki−hash[nums[i]]<=k。若满足，返回TrueTrue。
# 将索引更新为当前索引，hash[nums[i]]=ihash[nums[i]]=i
# 返回FalseFalse

# 复杂度分析
# 时间复杂度：O\left(n\right)O(n)，进行了一次遍历。
# 空间复杂度：O(n)O(n)，借助hashhash存储过程。


class Solution:
    def containsNearbyDuplicate(self,nums:List[int],k:int) -> bool:
        hash = {}
        for i in range(len(nums)):
            if(nums[i] not in hash):
                hash[nums[i]]=i
            else:
                if(i - hash[nums[i]] <= k):
                    return True
                else:
                    hash[nums[i]] = i
        return False

1.3 给定一个整数数组，判断是否存在重复元素。

如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。

# class Solution:
#     def containsDuplicate(self, nums: List[int]) -> bool:
# 方法1；思路：
# 思路一：暴力

# 时间复杂度：O(n^2)O(n 
# 2
#  )（超时）

# 无空间

# class Solution:
#     def containsDuplicate(self, nums: List[int]) -> bool:
#         for i in range(len(nums)):
#             for j in range(i + 1, len(nums)):
#                 if nums[i] == nums[j]:
#                     return True
#         return False
# 思路二：排序

# 时间复杂度：O(nlog(n))O(nlog(n))

# 无空间

# class Solution:
#     def containsDuplicate(self, nums: List[int]) -> bool:
        
#         if not nums: return False
#         nums.sort()
#         for i in range(1, len(nums)):
#             if nums[i - 1] == nums[i]: return True
#         return False
# 思路三：哈希

# 用字典记录以及访问的元素

# 时间复杂度：O(n)O(n)

# 空间复杂度：O(n)O(n)

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        visited = set()
        for num in nums:
            if num in visited:return True
            visited.add(num)
        return False

11