【基本数据结构】python array数组 [easy] leetcode1,53,88,118,121,217,350,566

数组leetcode有关题目(easy) python

使用语言python，解法的时间复杂度和空间复杂度都在平均水平之上，个别有90%左右的，不做具体说明。但是可以提升效率的点会进行说明，用粗体标出。考点和简要的中文也都在文章中标注出来了。

通过leetcode上数组的简单题目我们知道，基本的需要我们掌握的基础的知识有：python中可以对数组进行的操作和通过算法设计得到结果并且让程序更快。下面分别来通过题目和代码说明下我的理解：

熟悉python中数组的操作

leetcode 217. Contains Duplicate 考集合使用

这一题就很简单了，只要数组里面有两个一样的，返回True，没有一样的返回False。因此直接遍历，并且把遍历过的元素放在一个集合里面，后面的如果在这个集合里面说明有重复的。

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

leetcode 88. Merge Sorted Array 考切片使用

这个其实很简单了…直接放代码啦~

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.
        """
        if n == 0:
            return
        if m == 0:
            nums1[0:] = nums2
            return
        nums1[m : len(nums1)] = nums2
        nums1.sort()

提升效率： python数组可以一大坨直接赋值，效率比遍历快很多 nums1[m : len(nums1)] = nums2 （感觉这题的数据给的这么的奇怪就是为了这个知识点啊~~）切片整个赋值的用处！

算法

leetcode53. Maximum Subarray 找最大和

简单的来说，就是需要找到一串和最大的子串，下面先让我们通过下图看看一些可能的情况：
// 里面的MaxNow是现在为止最大的和，MoveOn是可能最大的和，根据图来解释下到底是什么意思。
（1）首先我们按照一般的思维从左到右加和，假设前面全部是负的，那么我们一定不要，因此我们假设全部是正的。这是第一个阶段，这个时候的MaxNow和MoveOn是一样的。
（2）第二个阶段的时候，出现了负数，因此有两个选择，要不继续加和，要不放弃前面所有的，因为是连续的子串。但是如左右两种情况，如果是左边，负数其实很少，那么左边可以稍微抵消一部分最后还是正的，遇到后面的正的时候，我们就知道不应该抛弃前面的。但是同时，也有可能负数很多，前面的不能抵消，因此我们也可能在后面找到最大的子串。
（3）因为这个原因，我们让MoveOn去继续的加和，只要不为小于0的数字就说明不会被抵消而保留，并且让MaxNow始终等于两个数字里面的最大值。
（4）假如MoveOn不幸的为负数了，我们只能抛弃前面的，让MoveOn归零并且继续往前加，再不断的比较MaxNow和MoveOn后来的值，看看需不需要改变MaxNow。
（5）根据以上的思路我们可以写出下面的代码。

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        MaxNow, MoveOn = nums[0],nums[0]
        for i in range(1,len(nums)):
            if MoveOn < 0 :
                MoveOn = nums[i]
            else:
                MoveOn += nums[i]
            MaxNow = max(MaxNow,MoveOn)
        return MaxNow

leetcode1. Two Sum 找给定和

这个就是找到数组里面相加之和等于给定的目标值的数字，并且给出两个数字的位置的索引，且根据题目，这样的解只有一个，就很简单了，思路是直接开始遍历，看看后面有没有，有的话先记下来第一个数字的索引，再在数组的后面的部分遍历，找到那个数字，记下索引，返回就可。

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        index = []
        for i in range(len(nums)):
            if target - nums[i] in nums[i+1:]:
                index.append(i)
                break
        for j in range(i+1,len(nums)):
            if nums[j] == target - nums[i]:
                index.append(j)
                return index

leetcode350. Intersection of Two Arrays II 找相同

直接放代码~比较长度是因为我觉得这样会快一些，不过其实最后就是50%左右的水平 ~

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        len1, len2 = len(nums1),len(nums2)
        intersect = []
        if len1> len2:
            for i in nums2:
                if i in nums1:
                    nums1.remove(i)
                    intersect.append(i)
        else:
            for i in nums1:
                if i in nums2:
                    nums2.remove(i)
                    intersect.append(i) 
        return intersect

121. Best Time to Buy and Sell Stock 找顺序最大差值

这一题在评论区有个哥们讲的很清楚，比我表达的还清楚，根据他的说法，我本来在两个分支都写了right+=1，后来改出来if循环了，结果快了一些

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if len(prices) == 1:
            return 0 
        left = 0
        right = 1
        max_profit = 0
        while right <= len(prices)-1:
            if prices[right]-prices[left]<0:
                left = right
            else:
                max_profit = max(max_profit,prices[right]-prices[left])
            right+=1
        return max_profit

最后的时间复杂度还行，空间复杂度还是均值

566. Reshape the Matrix

这一题感觉只要知道矩阵是一行行写怎么计算就可以
（我最开始的时候import numpy写的居然也可以，但是效率太低了哈哈哈…不过实际中，大家都会用numpy吧？）

class Solution:
    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
        row = len(mat)
        col = len(mat[0])
        if r*c != row*col:
            return mat
        reshapeMatrix = [[0]*c for i in range(r)]
        m,n = 0,0
        for i in range(r*c):
            reshapeMatrix[m][n] = mat[i//col][i%col]
            if n<c-1: n+= 1
            else: 
                m+=1
                n = 0
        return reshapeMatrix

这一题我最后做到runtime是95.08%，memory是81.87%。但是其实我写了三版，这一版最快。主要是矩阵的赋值的地方不一样。但是原因很奇怪，因为这样手动计算复杂度没区别啊!
我放在下面：

118. Pascal’s Triangle

这个只要索引能够对上就很简单啦！这个的runtime做到了95.6%

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        pascal = [[0]*(i+1) for i in range(numRows)]
        count = 1
        for i in range(numRows*(numRows+1)//2):
            index = i - (count-1)*count//2  # positionin the row
            if index > count-1:
                count+=1
                index = i - (count-1)*count//2  # positionin the row
            if index == 0 or index == count-1:
                pascal[count-1][index] = 1
            else:
                pascal[count-1][index] = pascal[count-2][index-1]+pascal[count-2][index]
        return pascal
        

算法结合数据结构

leetcode36. Valid Sudoku

这题的思路其实非常的简单，即需要分别判断，行有没有重复，列有没有重复，以及每一个小的sub方阵有没有重复。关键的是怎么写可以效率更高。一开始我是这样写的，使用了列表解析，后面的小方阵的判断是直接写了坐标。

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        for i in board:
            extract = [j for j in i if j!='.']
            if len(extract)!= len(set(extract)):
                return False
        for i in range(9):
            extract = [j[i] for j in board if j[i]!='.']
            if len(extract)!= len(set(extract)):
                return False
        location = [(0,0),(3,0),(6,0),
                    (0,3),(3,3),(6,3),
                    (0,6),(3,6),(6,6)]
        loc_box = [(0,0), (0,1), (0,2),
                   (1,0), (1,1), (1,2),
                   (2,0), (2,1), (2,2)]
        for k in location:
            i = k[0]
            j = k[1]
            extract = [board[m+i][n+j] for m,n in loc_box if board[m+i][n+j]!='.']
            if len(extract)!= len(set(extract)):return False
        return True

后来看见评论区里面更快的方式是：

class Solution:
    def isValidSudoku(self, board: List[List[str]]) -> bool:
        
        def init_mapper():
            return {i: {} for i in range(9)}
        
        mapper_row = init_mapper()
        mapper_col = init_mapper()
        mapper_box = init_mapper()
        pos_box = {(0,0): 0, (0,1): 1, (0,2): 2,
                   (1,0): 3, (1,1): 4, (1,2): 5,
				   (2,0): 6, (2,1): 7, (2,2): 8,}
        
        for r, row in enumerate(board):
            for c, item in enumerate(row):
                if item == ".":
                    continue
                b = pos_box[(r // 3, c // 3)]
                if mapper_row[r].get(item, False) or mapper_col[c].get(item, False) or mapper_box[b].get(item, False):
                    # repeated item
                    return False
                else:
                    mapper_row[r][item] = True
                    mapper_col[c][item] = True
                    mapper_box[b][item] = True
                
        return True

这个里面很巧妙的使用了 enumerate，这样相当于可以把所有的信息利用坐标的方式进行存储
于是可以一次遍历直接得到结果，而不用遍历三次，效率很低。这个字典的使用是很值得学习的。（查找判断很方便）