DataWhale 2023.09组队学习（Leetcode算法入门与数组篇）

 01.01 数据结构与算法简介、Leetcode入门及攻略（第01~02天）

Day1 01.01.04 练习题目

        2235.两整数相加

        直接返回num1+num2即可。

class Solution:
    def sum(self, num1: int, num2: int) -> int:
        return num1+num2

        1929.数组串联

        由于构建长度为2n的答案数组ans。经过分析，不难发现，ans是对nums数组进行复制了一份添加在后面。因此可以通过nums*2得到结果。

class Solution:
    def getConcatenation(self, nums: List[int]) -> List[int]:
        return nums*2

        771.宝石与石头

        此题需要比对字符串jewels中的字符是否在字符串stones中出现，并统计出现的个数。因此用两层循环，外层对stones进行循环，内层对jewels进行循环，如果存在，则宝石数+1。

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        num=0
        for i in stones:
            for j in jewels:
                if i==j:
                    num=num+1
        return num

Day2 01.01.05练习题目

        1480.一维数组的动态和

        此题相当于输出一个新数组，其中第i个元素是数组nums的前i个元素之和。因此，定义一个result数组存放结果。用循环算出nums中前i个元素之和时，将其加入至result数组中。

class Solution:
    def runningSum(self, nums: List[int]) -> List[int]:
        result=[]
        temp=0
        for i in range(len(nums)):
            temp=temp+nums[i]
            result.append(temp)
        return result

        709.转换成小写字母

        对字符串使用lower(）方法，即可将其转换为小写。相反，如果需要大写，使用upper()方法。

class Solution:
    def toLowerCase(self, s: str) -> str:
        return s.lower()

        1672.最富有的客户资产总量

        对于二维数组在python中，实际上是一个列表中的每一个元素依旧是列表。因此对列表进行循环，计算出每个元素（也是列表）的和，比较出其中的最大值即可。

class Solution:
    def maximumWealth(self, accounts: List[List[int]]) -> int:
        maxResult=0     #最富有的客户资产总量
        for i in accounts:
            result=sum(i)   #每个客户在所有银行中的资产总数
            if result>=maxResult:
                maxResult=result
        return maxResult

01.02 数组基础（第03~04天）

 Day3 01.02.02 练习题目

        66.加一

        此题目由于是将整数的每一个数字转化成数组元素后，求整数+1后的数组化形式。因此我想到将已知数组转化成数字，+1后，再次转换回数组形式。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        num=0
        renew=[]
        for i in digits:    #将数组转换回数字形式
            num=(num+i)*10
        num=num//10+1   #最终所转换成的数字
        while num>0:    #拆分成单个数组元素并且插入数组，头插
            temp=num%10
            num=num//10
            renew.insert(0,temp)
        return renew

        724.寻找中心数组下标

        此题目可以先计算i左边的元素之和preSum，再用整个数组之和numsSum-preSum-nums[i]。即可得到右边数组之和nextSum。如果左右部分数组值和相等则返回当前i下标，否则，返回-1。

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        numsSum=sum(nums)
        preSum=0
        for i in range(len(nums)):
            #preSum=preSum+nums[i],  第一次比对不是此处，第一次比对时左边的preSum等于0，因此将求preSum语句放在判断之后。
            if preSum==numsSum-preSum-nums[i]:
                return i 
            preSum=preSum+nums[i]              
        return -1   

        189.轮转数组

        对此题进行分析，根据其将数组中的元素向右轮转k个位置，我们可以想到，对下标i+k，由与相当于对数组元素进行循环，可以想到，如果i+k>len(nums)，那我们进行对数组长度取模，就可以将其下标值控制到索引范围以内。

        需要注意使用python3要nums.copy()，不能直接等于，否则nums和numsTemp指向内存中同意数组。

class Solution:
    def rotate(self, nums,k):
        """
        Do not return anything, modify nums in-place instead.
        """
        Length=len(nums)
        numsTemp=nums.copy()
        for i in range(Length):
            nums[(i+k)%Length]=numsTemp[i]

Day4 01.02.03 练习题目

        48.旋转图像

        假设有n阶方阵，此题目是将矩阵元素a[0][0]移动到a[0][n]，a[0][2]移动到a[2][n]，抽象后可得到数学表达式a[i][j]==a[j][n-i-1]。因此可以利用辅助数组来实现。

        注意代码中的matrixTemp=copy.deepcopy(matrix)

        此处不能使用像189题.轮转数组那样复制。这里涉及到浅拷贝和深拷贝的原因

import copy
class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        length=len(matrix)
        matrixCopy=copy.deepcopy(matrix)
        #matrixTemp=matrix.copy()并没有实现深拷贝，而是进行了浅拷贝。
        for i in range(length):
            for j in range(length):
                matrix[j][length-i-1]=matrixCopy[i][j]
        

        54.螺旋矩阵

        此题目用的是一种模拟思维，模拟输出螺旋矩阵的过程。用visited标记矩阵元素是否访问。在螺旋的过程中有上下左右四个方向。每次判断下一个位置是否合法，不合法就旋转。

class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        m=len(matrix)
        n=len(matrix[0])
        count=m*n
        visited=[[False]*n for _ in range(m)]
        result=[0]*count
        direction=[[0,1],[1,0],[0,-1],[-1,0]]
        i,j=0,0
        directionIndex=0
        for s in range(count):
            result[s]=matrix[i][j]
            visited[i][j]=True
            iNext=i+direction[directionIndex][0]
            jNext=j+direction[directionIndex][1]

            if not (0<=iNext<m and 0<=jNext<n and visited[iNext][jNext]==False):
                directionIndex=(directionIndex+1)%4
                
            i=i+direction[directionIndex][0]
            j=j+direction[directionIndex][1]
        return result
            

        498.对角线遍历

        此题目与上题一致，使用一种模拟整个过程的思维。共有m+n-1条对角线，相邻对角线遍历方向不同。

        i为偶数，遍历方向左下到右上（行索引-1，列索引+1）；

        i为奇数，遍历方向右上到左下（行索引+1，列索引-1）。

class Solution:
    def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
        result=[]
        m=len(mat)
        n=len(mat[0])
        for i in range(m+n-1):
            if i%2:
                if i<n:
                    x,y=0,i
                else:
                    x,y=i-n+1,n-1
                while x<m and y>=0:
                    result.append(mat[x][y])
                    x,y=x+1,y-1
            else:
                if i<m:
                    x,y=i,0
                else:
                    x,y=m-1,i-m+1
                while x>=0 and y<n:
                    result.append(mat[x][y])
                    x,y=x-1,y+1
        return result