LeetcodeTask2数组基础

基础知识

• 定义：一种线性表数据结构。它使用一组连续的内存空间，来存储一组具有相同类型的数据。
• 特点：可以进行随机访问——根据下标通过「寻址公式」 计算出对应元素的内存地址，访问地址对应的数据元素。

寻址公式：下标 i 对应的数据元素地址 = 数据首地址 + i * 单个数据元素所占内存大小

• 基本操作：增删改查
  习题
  加一

给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        i=len(digits)-1
        while i>=0 and digits[i]==9:
           digits[i]=0
           i-=1#末尾为9需进位，例1999
        if i>=0 and digits[i]<9:
            digits[i]+=1#末尾不为9，无需进位
        else:
            digits=[1]+digits#各数位均为9，如999
        return digits

寻找数组的中心下标

给你一个整数数组 nums ，请计算数组的 中心下标 。
数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        left=0
        sum = 0
        for num in ramge nums:
            sum += num
		right = sum
		for i in range(len(nums)):
			if i == 0:
				right -= nums[0]
			else:
				right -= nums[i]
				left += nums[i-1]
			if right == left:
				return i
		return -1

轮转数组

给你一个数组，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

   k=k%len(nums) #这里要注意k>n的情况
   nums[:]=nums[len(nums)-k:]+nums[:len(nums)-k]
   return nums

旋转图像

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。
你必须在 原地 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

 n = len(matrix)
        for i in range(n):
            for j in range(i + 1, n):
                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
        for i in range(n):
            for j in range(n // 2):
                matrix[i][j], matrix[i][n - j - 1] = matrix[i][n - j - 1], matrix[i][j]
#主对角线反转+左右翻转

螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

#这道题纯靠大神，思路：循环遍历矩阵，适时改变方向
class Solution:
    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
        if not matrix:return []

        x=y=0                                     # 矩阵元素位置初始化
        res = []                                  # 初始化，存储遍历后的矩阵元素
        dx = [ 0, 1, 0,-1]                        # 方向：右，下，左，上
        dy = [ 1, 0,-1, 0]                        # 注：与通常平面坐标系 记号 不同
        di = 0                                    # 初始化方向变量
        visited = set()                           # 初始化集合，存储已走过的坐标
        m,n = len(matrix),len(matrix[0])          # 矩阵的行列 
                
        for i in range(m*n):                                     # 
            res.append(matrix[x][y])                             # 存储遍历矩阵过的元素
            visited.add((x,y))                                   # 存储遍历过的坐标
            tx,ty = x+dx[di],y+dy[di]                            # 先记录下一步坐标，用于判断下一步怎么走
            if 0<=tx<m and 0<=ty<n and (tx,ty) not in visited:   # 判断坐标是否需变向，且没有遍历过
                x,y = tx,ty                                       
            else:                                                
                di = (di+1)%4                                    # 改变方向，右下左上为一圈，防止方向坐标越界
                x,y = x + dx[di],y+dy[di]                        # 下一步坐标
        return res

对角线遍历

给你一个大小为 m x n 的矩阵 mat ，请以对角线遍历的顺序，用一个数组返回这个矩阵中的所有元素。

#最后两道题我已经咸鱼了，下面是我搬运大佬的解法
class Solution:
  def findDiagonalOrder(self, mat: List[List[int]]) -> List[int]:
    dir = [(-1, 1), (1, -1)]
    r, c = len(mat), len(mat[0])
    res = []
    i = 0
    j = 0
    temp = 0
    while temp < r + c - 1:
      while 1:
        res.append(mat[i][j])
        i += dir[temp % 2][0] # 偶数次向上遍历, 奇数次向下遍历
        j += dir[temp % 2][1]
        # 四个方向
        if i < 0 and j < c:
          i = 0
          break
        elif j < 0 and i < r:
          j = 0
          break
        elif j == c:
          j = c - 1
          i += 2 # 行超出边界,向下前进两个位置
          break
        elif i == r:
          i = r - 1
          j += 2 # 列超出边界,向右前进两个位置
          break
      temp += 1
    return res