02 ｜ 数组

知识点

• 数组是一种简单的数据结构，是由相同类型的元素组成的数据集合，并且占据一块连续的内存并按照顺序存储数据。
• 双指针是一种常用的解题思路，前提条件是数组中的所有数字都是正数。可以使用两个相反方向或相同方向的指针扫描数组从而达到解题目的。在数组里指针指的是数字的下标。
• 方向相反的双指针经常用来求排序数组中的两个数字之和；方向相同的双指针通常用来求正数数组中子数组的和或乘积。
• 当不能使用双指针时，可以尝试累加数组数字求子数组之和的方法。

基础练习

1. 排序数组中两个数字之和

Leecide.167

解题思路

由于数组是递增排序的，可以使用二分查找。

python3答案

class Solution:
    def twoSum(self, numbers: List[int], target: int) -> List[int]:
        n = len(numbers)
        for i in range(n):
            low, high = i + 1, n - 1
            while low <= high:
                mid = (low + high) // 2
                if numbers[mid] == target - numbers[i]:
                    return [i, mid]
                elif numbers[mid] > target - numbers[i]:
                    high = mid - 1
                else:
                    low = mid + 1
        
        return [-1, -1]

2. 数组中和为0的3个数字

Leetcode.15

解题思路

1. 先将数组排序，注意数组中有重复的元素。
2. 从左至右遍历数组，把0 - nums[i]作为target，对剩下的数组元素进行twoSum,使用双指针p1, p2查找，如果两元素之和小于target, 则p1右移，大于则p2左移，等于则加入result list中。
3. 在遍历数组元素过程中，遇到重复的需要跳过，避免加入重复的三元组。

python3实现

class Solution:
    def twoSum(self, numbers: List[int], k: int, target: int, result: List[int]):
        p1 = k+1
        p2 = len(numbers) - 1
        while p1 < p2:
            if numbers[p1] == target - numbers[p2]:
                result.append([numbers[p1],numbers[p2],numbers[k-1]])  
                tmp = numbers[p1]
                while tmp == numbers[p1] and p1 < p2:
                    p1 += 1
            elif numbers[p1] > target - numbers[p2]:
                p2  -= 1 
            else:
                p1 +=1
        return None

    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        result = []
        i = 0
        n = len(nums)
        while i < n - 2:
            target = 0 - nums[i]
            self.twoSum(nums, i+1, target,result)
            tmp = nums[i]
            while tmp == nums[i] and i < n-1:
                i += 1
        return result

3. 和大于等于 target 的最短子数组

Leecide.209

解题思路

使用双指针，p1和p2初始化都在数组第一个元素，计算p1和p2之间子数组之和，如果小于target则p2向右移，反之p1向右移动。

python3答案

class Solution:
    def minSubArrayLen(self, s: int, nums: List[int]) -> int:
        p1, p2 = 0, 0 
        min_value = sys.maxsize
        tmp = nums[p1]
        flag = False
        while p1 <= p2 and p2 < len(nums):
            if tmp < s:
                p2 += 1
                if p2 < len(nums):
                    tmp += nums[p2]
            else:
                min_value = min(min_value, p2-p1+1)
                flag = True
                tmp -= nums[p1]
                p1 += 1
        return min_value if flag else 0
                    

4. 和为 k 的子数组

Leecide.560

解题思路

1. 由于题目没有说是正整数，所以不能通过移动双指针来改变子数组的累加和。可以用累加数组求子数组之和。
   例如，假如k=9, 在数组[1，2，3，4，5，6]中，从下标0开始到下标2结束的子数组[1，2，3]之和是6，从下标0开始到下标4结束的子数组[1，2，3，4，5]之和为15，那么和为15-9的子数组出现次数符合要求。从下标3开始到下标4结束的子数组[4，5]之和是9，正好15-9=6。
2. 从头遍历数组累加后存入哈希表，key为累加和，value为出现的次数。如果value>=k，将和为value-k的子数组次数相加即可。

python3答案

class Solution:
    def subarraySum(self, nums, k):
        ret = pre_sum = 0
        pre_dict = {0: 1}
        for i in nums:
            pre_sum += i
            ret += pre_dict.get(pre_sum - k, 0)
            pre_dict[pre_sum] = pre_dict.get(pre_sum, 0) + 1
        return ret

扩展练习

无重复字符的最长子串

Leetcode.3

解题思路

定义一个空列表，遍历字符串，如果不在空列表里则加进去，如果在，1. 判断列表长度是否为最大并赋给max_size；2.找到首次出现字母的索引位置，把新的字母加进去，截取索引位置后的列表

python3答案

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if len(s) == 0:
            return 0
        
        tmp_list = []
        max_size = -2**31
        for i in s:
            if i in tmp_list:
                max_size = max(len(tmp_list),max_size)
                first_index = tmp_list.index(i)
                tmp_list.append(i)
                tmp_list = tmp_list[first_index+1:]
            else:
                tmp_list.append(i)

        return max(len(tmp_list),max_size)
        

四数之和

Leetcode.18

两数之和、三数之和、四数之和有什么规律吗？