数据结构学习笔记1：数组

1. 数组

• 很简单，也很常用，一般结合其他知识点考察

题目：217. 存在重复元素

代码模板：

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        # 遍历
        dct = set()
        for n in nums:
            if n not in dct:
                dct.add(n)
            else:
                return True
        return False

题目：1. 两数之和

代码模板：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        dct = {
    
    }
        for i, v in enumerate(nums):
            if v in dct:
                return [dct[v], i]
            else:
                dct[target-v] = i

力扣第一题，很经典了

题目：88. 合并两个有序数组

代码模板：

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        # 从后往前遍历，双指针
        k = len(nums1)-1
        m -= 1
        n -= 1
        while k > -1:
            if n > -1 and m > -1:
                if nums1[m] < nums2[n]:
                    nums1[k] = nums2[n]
                    n -= 1
                else:
                    nums1[k] = nums1[m]
                    m -= 1
            elif n > -1:
                nums1[k] = nums2[n]
                n -= 1
            # 如果 n== -1，可以直接return
            else:
                return
            k -= 1

经典的思路转变，从后往前遍历

题目：350. 两个数组的交集 II

代码模板：

# 法1
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # 不借助Counter
        nums1.sort()
        nums2.sort()
        res = []
        n1, n2 = len(nums1), len(nums2)
        i = j = 0
        while i < n1 and j < n2:
            if nums1[i] < nums2[j]:
                i += 1
            elif nums1[i] > nums2[j]:
                j += 1
            else:
                res.append(nums1[i])
                i += 1
                j += 1
        return res

# 法2
class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        # 借助Counter，在二者长度差异大的时候效率高
        if len(nums1) > len(nums2):
            return self.intersect(nums2, nums1)
        
        res = []
        ctr = Counter(nums1)
        for n in nums2:
            if n in ctr:
                ctr[n] -= 1
                res.append(n)
                if ctr[n] == 0:
                    ctr.pop(n)
        return res

这道题还是使用哈希表查询效率更好，尤其是nums1和nums2长度差异大的时候

题目：36. 有效的数独

代码模板：

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        row = [[0] * 9 for _ in range(9)]
        col = [[0] * 9 for _ in range(9)]
        mat = [[[0] * 9 for _ in range(3)] for _ in range(3)]
        # mat最先定义的在最后索引
        for i in range(9):
            for j in range(9):
                c = board[i][j]
                if c != '.':
                    idx = int(c) - 1
                    row[i][idx] += 1
                    col[idx][j] += 1
                    mat[i//3][j//3][idx] += 1
                    if row[i][idx]>1 or col[idx][j]>1 or mat[i//3][j//3][idx]>1:
                        return False
        return True

如果种类固定，使用数组也可以实现哈希表类似的查重功能