2024/12/10 【哈希表】LeetCode18.四数之和 【√】哈希表篇总结

代码随想录

18. 四数之和 - 力扣（LeetCode）

参照LeetCode13，三数之和的双指针解题思路。

要注意，不要判断nums[i] > target就返回了。

我的解法：

类似三数之和，先确定left和right指针分别为i+1和len(nums)-1,而mid（第三个指针）设置为right-1

代码随想录给出的解法是j等于i+1，然后left和right分别为j+1和len(nums)-1

我的：不足是推广到N数之和的适应性不强。

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        res = []
        nums.sort()
        for i in range(len(nums)):
            # if nums[i] > target:
            #     return res
            
            if i > 0 and nums[i] == nums[i-1]:
                continue

            move_l = i+1
            right = len(nums)-1
            while(move_l+1 < right):
                move_r = right-1
                while(move_l < move_r):
                    sum = nums[i] + nums[move_l] + nums[move_r] + nums[right] 
                    if sum < target:
                        move_l += 1
                    elif sum > target:
                        move_r -= 1   
                    else:
                        res.append([nums[i], nums[move_l], nums[move_r], nums[right]])
                        while move_l < move_r and nums[move_l] == nums[move_l+1]:
                            move_l += 1
                        while move_l < move_r and nums[move_r] == nums[move_r-1]:
                            move_r -= 1
                        move_l += 1
                        move_r -= 1  
                move_l = i+1
                while move_l+1 < right and nums[right] == nums[right-1]:
                    right -= 1
                right -= 1
        return res

 代码随想录：

class Solution:
    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:
        nums.sort()
        n = len(nums)
        result = []
        for i in range(n):
            if nums[i] > target and nums[i] > 0 and target > 0:# 剪枝（可省）
                break
            if i > 0 and nums[i] == nums[i-1]:# 去重
                continue
            for j in range(i+1, n):
                if nums[i] + nums[j] > target and target > 0: #剪枝（可省）
                    break
                if j > i+1 and nums[j] == nums[j-1]: # 去重
                    continue
                left, right = j+1, n-1
                while left < right:
                    s = nums[i] + nums[j] + nums[left] + nums[right]
                    if s == target:
                        result.append([nums[i], nums[j], nums[left], nums[right]])
                        while left < right and nums[left] == nums[left+1]:
                            left += 1
                        while left < right and nums[right] == nums[right-1]:
                            right -= 1
                        left += 1
                        right -= 1
                    elif s < target:
                        left += 1
                    else:
                        right -= 1
        return result

哈希表篇总结

1.数组就是简单的哈希表，但是数组的大小是受限的，受到系统栈空间（不是数据结构的栈）的限制。

2.有些题目，使用map的空间消耗要比数组大一些，因为map要维护红黑树或者符号表，而且还要做哈希函数的运算。所以数组更加简单直接有效。

3.map是一种<key, value>的结构。

4.C++提供如下三种map：

• std::map
• std::multimap
• std::unordered_map

std::unordered_map 底层实现为哈希，std::map 和std::multimap 的底层实现是红黑树。

同理，std::map 和std::multimap 的key也是有序的（这个问题也经常作为面试题，考察对语言容器底层的理解）。

完结撒花*★,°*:.☆(￣▽￣)/$:*.°★* 。