LeetCode算法笔记 【第一章：算法入门与数组篇】

目录

2 数组基础

01、数组基础知识

（1）数组简介

数组定义

随机访问数据元素

多维数组

不同语言中的数组实现

（2）数组基本操作

访问元素

查找元素

插入元素

改变元素

删除元素

02、练习题目

（1）加一

（2）寻找数组的中心下标

（3）轮转数组

（4）旋转图像

（5）螺旋矩阵

（6）对角线遍历

03、数组基础知识题目

（1）最大连续1的个数

（2）除自身以外数组的乘积

（3）矩阵置零

（4）螺旋矩阵Ⅱ

（5）生命游戏

---

2 数组基础

01、数组基础知识

（1）数组简介

---

数组定义:

数组是一种线性结构，是一连串连续空间，存储相同类型数据

---

随机访问数据元素

每个元素都有各自地址，各个元素都可根据下标进行随机访问

第一个元素地址为首地址

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

---

多维数组

只有一个维度的数组为一维数组

多维数组是有多个维度的数组

以二维数组为例，其本质上就是数据元素为一维数组的数组，可以看作是一个矩阵

---

不同语言中的数组实现

c/c++：使用一块连续内存空间来存储数组，数据元素连续。定义如下：

int arr[2][3] = {{1,2,3},{4,5,6}};

java：数组存储数据类型相同，但存储空间不连续。定义如下：

int [][]arr ={{1,2},{1,2,3},{1,2,3,4,5}} ;

python：在python中数组用列表替代，列表储存数据类型可不一致。定义如下：
 

arr = [1,2,3,'a','python']

（2）数组基本操作

访问元素:

通过访问元素的下标值得到元素的值，（访问下标要在范围内）

访问第三个元素：

arr = [1,2,3,4,5]
a = arr[2]
print(a)

---

查找元素:

指查找元素的下标，使用函数index（）

如查找元素2下标值：

nums=[1,2,3]
a=nums.index(2)
print(a)

---

插入元素：

使用函数append（），程序会自动在列表最后开辟一块新空间

如插入元素（a=5）到列表末尾：

arr = [1,2,3,4]
a = 5
arr.append(a)
print(arr)

---

改变元素

语法：列表[下标] = 修改值

如修改第三个元素为9：

arr = [1,2,3,4,5]
arr[2] = 9
print(arr)

---

删除元素

分为三种：

1、删除尾部元素：

使用pop（）函数括号中不添数，自动判定删除最后元素值

如删除最后一个元素值：

arr = [1,2,3,4,5]
arr.pop()
print(arr)

2、，已知元素下标，删除指定下标的元素：

用函数pop（下标），可删除指定下标的函数

如删除元素（4）：

arr = [1,2,3,4,5]
arr.pop(3)
print(arr)

3、已知元素值，删除指定元素：

使用函数remove（元素值）：

arr = ['python','java','c','c++']
arr.remove('python')
print(arr)

02、练习题目

（1）加一

题目：给定一个非负整数数组，数组每一位对应整数的一位数字。计算整数加 1 后的结果。

class Solution(object):
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        l=len(digits)
        digits[l-1]+=1 # 整数加一
        for i in range(l-1,0,-1):   #逢十进一
            if digits[i]==10 :
                digits[i-1]+=1
                digits[i]=0    
        if digits[0]==10:    # 首位是九加一位
            digits[0]=1
            digits.append(0)
        return digits        

（2）寻找数组的中心下标

题目：

给你一个整数数组 nums ，请计算数组的 中心下标 。

数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。

如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。

如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 -1 。

​
​class Solution(object):
    def pivotIndex(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        l = len(nums)
        sums=sum(nums) #求数组总和
        num=0
        for i in range(l):
            if num == sums-nums[i]-num:  #判定条件
                return i 
            num+=nums[i]    
        return -1

​

​

（3）轮转数组

题目：给定一个数组 nums，再给定一个数字 k，将数组中的元素向右移动 k 个位置。

class Solution(object):
    def rotate(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        l = len(nums)
        for i in range(k):
            n=nums[l-1]
            nums.pop(l-1)
            nums.insert(0,n)
        

（4）旋转图像

题目：

给定一个 n×n 大小的二维矩阵（代表图像）matrix，将二维矩阵 matrix 顺时针旋转 90°。

如图：

题解：

class Solution(object):
    def rotate(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        l = len(matrix)
        for i in range(l//2):
            for j in range(i,l-i-1):
                n=matrix[i][j]
                matrix[i][j]=matrix[l-1-j][i]
                matrix[l-1-j][i]=matrix[l-1-i][l-1-j]
                matrix[l-1-i][l-1-j]=matrix[j][l-1-i]
                matrix[j][l-1-i]=n

（5）螺旋矩阵

题目：  给定一个 m×n 大小的二维矩阵 matrix,按照顺时针旋转的顺序，返回矩阵中的所有元素。

class Solution(object):
    def spiralOrder(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: List[int]
        """
        h=len(matrix)
        w=len(matrix[0])
        n=h*w
        l=0
        r=w-1
        u=0
        d=h-1
        result=[]
        while n>=1:
            for i in range(l,r+1):
                if n>=1:
                    result.append(matrix[u][i])
                    n-=1
            u+=1
            for i in range(u,d+1):
                if n>=1:
                    result.append(matrix[i][r])
                    n-=1
            r-=1
            for i in range(r,l-1,-1):
                if n>=1:
                    result.append(matrix[d][i])
                    n-=1
            d-=1
            for i in range(d,u-1,-1):
                if n>=1:
                    result.append(matrix[i][l])
                    n-=1
            l+=1
        return result

（6）对角线遍历

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

如图：

输出[1,2,4,7,5,3,6,8,9]

class Solution(object):
    def findDiagonalOrder(self, mat):
        """
        :type mat: List[List[int]]
        :rtype: List[int]
        """
        m=len(mat)
        n=len(mat[0])
        flag=0
        sum=[]
        for i in range(m+n-1):
            if flag:
                for j in range(max(0,i-n+1),min(i+1,m)):
                    sum.append(mat[j][i-j])
                flag=0
            else:
                for j in range(min(m-1,i),max(-1,i-n),-1):
                    sum.append(mat[j][i-j])
                flag=1 
        return sum

03、数组基础知识题目

（1）最大连续1的个数

题目：给定一个二进制数组 nums ， 计算其中最大连续 1 的个数。

nums=[1,1,0,1,1,1]
n=0
num=0
l=len(nums)
for i in range(l):
    if nums[i]==0:
        if num>n:
            n=num
        num=0
        continue
    num+=1
if num>n:
    n=num
print(n)

（2）除自身以外数组的乘积

题目：

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

class Solution(object):
    def productExceptSelf(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        n=len(nums)
        answer=[1]
        num=1
        r=1
        for i in range(1,n):
            answer.append(answer[i-1]*nums[i-1])
        for i in range(n-1,-1,-1):
            answer[i]*=r
            r*=nums[i]
        return answer

（3）矩阵置零

题目：给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 

class Solution(object):
    def setZeroes(self, matrix):
        """
        :type matrix: List[List[int]]
        :rtype: None Do not return anything, modify matrix in-place instead.
        """
        r=set()
        c=set()
        l=len(matrix)
        h=len(matrix[0])
        for i in range(l):
            for j in range(h):
                if matrix[i][j]==0:
                    r.add(i)
                    c.add(j)
        for i in r:
            for j in range(h):
                matrix[i][j]=0
        for i in c:
            for j in range(l):
                matrix[j][i]=0

（4）螺旋矩阵Ⅱ

题目：给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 

class Solution(object):
    def generateMatrix(self, n):
        """
        :type n: int
        :rtype: List[List[int]]
        """
        num=1
        l=0
        r=n-1
        u=0
        d=n-1
        matrix = [[0 for _ in range(n)] for _ in range(n)]
        while num<=n*n:
            for i in range(l,r+1):
                matrix[u][i]=num
                num+=1
            u+=1
            for i in range(u,d+1):
                matrix[i][r]=num
                num+=1
            r-=1
            for i in range(r,l-1,-1):
                matrix[d][i]=num
                num+=1
            d-=1
            for i in range(d,u-1,-1):
                matrix[i][l]=num
                num+=1
            l+=1
        return matrix

（5）生命游戏

题目： 生命游戏 ，简称为 生命 ，是英国数学家约翰·何顿·康威在 1970 年发明的细胞自动机。

给定一个包含 m × n 个格子的面板，每一个格子都可以看成是一个细胞。每个细胞都具有一个初始状态： 1 即为 活细胞 （live），或 0 即为 死细胞 （dead）。每个细胞与其八个相邻位置（水平，垂直，对角线）的细胞都遵循以下四条生存定律：

1. 如果活细胞周围八个位置的活细胞数少于两个，则该位置活细胞死亡；
2. 如果活细胞周围八个位置有两个或三个活细胞，则该位置活细胞仍然存活；
3. 如果活细胞周围八个位置有超过三个活细胞，则该位置活细胞死亡；
4. 如果死细胞周围正好有三个活细胞，则该位置死细胞复活；

下一个状态是通过将上述规则同时应用于当前状态下的每个细胞所形成的，其中细胞的出生和死亡是同时发生的。给你 m x n 网格面板 board 的当前状态，返回下一个状态。

class Solution(object):
    def gameOfLife(self, board):
        """
        :type board: List[List[int]]
        :rtype: None Do not return anything, modify board in-place instead.
        """
        y = len(board[0])
        newboard = [(y+2)*[0]]+[[0]+i[:]+[0] for i in board]+[[0]*(y+2)] # 使面板扩充一圈
        x = len(newboard)
        y += 2
        sum=0
        for i in range(1, x-1):
            for j in range(1, y-1):
                for k in range(i-1,i+2):
                    for t in range(j-1,j+2):
                        sum+=newboard[k][t]
                sum-=newboard[i][j]
                if newboard[i][j]:  #判断
                    if sum<2 or sum > 3:
                        board[i-1][j-1] = 0
                else:
                    if sum == 3:
                        board[i-1][j-1] = 1
                sum=0