LeetCode-Python 数组专题（学习笔记+代码）_给定一个整数数组 nums,编写一个程序,计算数组中的元素总和。 输入: 5 1 2 3 4 5

---

leetcode1.两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
1
2
3

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
1
2

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/two-sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
暴力解法，遍历

class Solution():
    def twosum(self,nums,target):
        for i in range(len(nums)):
            #从i+1开始，避免重复使用同一个元素
            for j in range(i+1,len(nums)):
                if nums[i]+nums[j] == target:
                    return[i ,j]
        return []

1
2
3
4
5
6
7
8
9

复杂度：O（n^2）
排序+双指针

class Solution():
    def twoSum(self,nums,target):
        #浅拷贝，没有子对象，可以直接用
        temp = nums.copy()
        #排序
        temp.sort()
        #指定双指针初始值
        i = 0
        #防止数组溢出
        j = len(temp)-1
        while(i < j):
            if temp[i] + temp[j] > target:
                j = j -1
            elif temp[i] + temp[j] <target:
                i = i +1
            else:
                break

        #寻找index时，注意题目中可能存在两个相等的数和为目标值，所以找到一个值后要pop掉
        a = nums.index(temp[i])
        nums.pop(a)
        b = nums.index(temp[j])
        #由于pop掉值了，所以要记得加回来
        if a <= b:
            b = b + 1
        return [a,b]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

复杂度：O（n）
哈希

class Solution(object):
    def twoSum(self, nums, target):
        dict = {}
        for index, item in enumerate(nums):
            if target - item in dict:
                return dict[target - item], index
            dict[item] = index


if __name__ == '__main__':
    nums = [2, 7, 11, 15]
    target = 9
    soultion = Solution()
    print(soultion.twoSum(nums, target))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

复杂度：O（n）

leetcode7.整数反转

给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。
如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。
假设环境不允许存储 64 位整数（有符号或无符号）。
示例 1：

输入：x = 123
输出：321
1
2

示例 2：

输入：x = -123
输出：-321
1
2

示例 3：

输入：x = 120
输出：21
1
2

示例 4：

输入：x = 0
输出：0
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/reverse-integer
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution():
    def reverse(self,x):
        #把数字做成字符
        tList = list(str(x))
        #判断是否为负
        if tList[0] == '-':
            rNum = int(''.join(tList[1:][::-1]))*(-1)
        else:
            rNum = int(''.join(tList[::-1]))
        #判断是否超出范围，这里我感觉不太对，假如这个环境只能
        #存这么大的数，那么更大的数应该会溢出报错呀，但通过没问题，疑惑
        if rNum in range(pow(2,31)*(-1),pow(2,31)):
            return rNum
        else:
            return 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

leetcode11.盛水最多的容器

给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
返回容器可以储存的最大水量。
说明：你不能倾斜容器。
示例 1：

输入：[1,8,6,2,5,4,8,3,7]
输出：49 
解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
1
2
3

示例 2：

输入：height = [1,1]
输出：1
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/container-with-most-water
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
双指针
将双指针作为左右边界，最开始在数组左右两端的位置，重复进行如下操作，直到双指针相遇：

计算当前边界构成容器容量，即S=min(a[i], a[j]) * (j - i)。
将当前容量最大值更新，即max_S = max(S, max_S)
判断两个边界的高度，即比较a[i]和a[j]，将较小的边界向另一个边界方向移动1。
1
2
3

class Solution:
    def maxArea(self, height: List[int]) -> int:
        left,right = 0, len(height)-1
        res = 0
        while left < right:
            if height[left] < height[right]:
                res = max(res,height[left]*(right-left))
                left += 1
            else:
                res = max(res,height[right]*(right-left))
                right -= 1
        return res

1
2
3
4
5
6
7
8
9
10
11
12
13

时间复杂度：O（n）

leetcode15.三数之和

给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
示例 1：

输入：nums = [-1,0,1,2,-1,-4]
输出：[[-1,-1,2],[-1,0,1]]
1
2

示例 2：

输入：nums = []
输出：[]
1
2

示例 3：

输入：nums = [0]
输出：[]
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/3sum
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
双指针
双指针的思想就是，每次固定一个数，设置左右两个指针，对三数之和的情况进行一个判断。
步骤：

首先对数组进行排序
遍历排序数组：
    当first > 0 时，如果nums[first ] == nums[first i-1]，那么跳过
    设置两个指针：left = first + 1和right = len(nums) - 1，当left < right时，执行循环
    当 nums[first ] + nums[left] + nums[right] < 0，说明nums[left]小了，left右移
    当 nums[first ] + nums[left] + nums[right] > 0，说明nums[right]大了，right左移
    当 nums[first ] + nums[left] + nums[right] == 0，执行循环
        判断左界和右界是否和下一位置重复，去除重复解
        并同时将 left和right 移到下一位置，寻找新的解
1
2
3
4
5
6
7
8
9

#双指针法，和两数之和类似
#注意跳过重复值
class Solution:
    def threeSum(self, nums):
        n = len(nums)
        res = []
        nums.sort()
        for first in range(n - 2):
            if first > 0 and nums[first] == nums[first - 1]:
                continue
            left, right= first + 1, n - 1
            while left< right:
                s = nums[first] + nums[left] + nums[right]
                if s < 0:
                    left+= 1
                elif s > 0:
                    right-= 1
                else:

                    res.append((nums[first], nums[left], nums[right]))
                    while left< right and nums[left] == nums[left+ 1]:
                        left+= 1
                    while left< right and nums[right] == nums[right- 1]:
                        right-= 1
                    left+= 1
                    right-= 1
        return res

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

时间复杂度：O（n^2）

leetcode26.删除排序数组中的重复项

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
判题标准:
系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}
1
2
3
4
5
6
7
8
9

如果所有断言都通过，那么您的题解将被 通过。
示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
1
2
3

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
1
2
3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
双指针

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        slow,fast = 0,0
        for fast in range(len(nums)):
            if nums[fast] != nums[slow]:
                slow += 1
                nums[slow] = nums[fast]                
        return slow + 1

1
2
3
4
5
6
7
8
9

leetcode42.接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

示例 1：

输入：height = [0,1,0,2,1,0,1,3,2,1,2,1]
输出：6
解释：上面是由数组 [0,1,0,2,1,0,1,3,2,1,2,1] 表示的高度图，在这种情况下，可以接 6 个单位的雨水（蓝色部分表示雨水）。 
1
2
3

示例 2：

输入：height = [4,2,0,3,2,5]
输出：9
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/trapping-rain-water
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
动态规划

class Solution():
    def trap(self, height):
        #边界条件，一定要判断，否则后面按照数组长度生成新数组的时候，如果为空，会产生溢出
        if not height: return 0
        n = len(height)#数组长度
        water = 0#储水量
        max_left = [0] * n #每个位置处，从左向右的最大值
        max_right = [0] * n #每个位置处，从右向左的最大值
        max_left[0] = height[0] #设置初始值
        max_right[n - 1] = height[n - 1] #设置初始值
        for i in range(1, n): #求从左向右的最大值
            max_left[i] = max(max_left[i - 1], height[i])
        for j in range(n - 2, -1, -1): #求从右向左的最大值
            max_right[j] = max(max_right[j + 1], height[j])
        for i in range(n): #每个位置处，都可以表中拿到左边最大值和右边最大值
            if min(max_left[i], max_right[i]) > height[i]:
                water += min(max_left[i], max_right[i]) - height[i]
        return water

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

时间复杂度：O（n）
双指针法

class Solution:
    def trap(self, height: List[int]) -> int:
        #边界条件
        if not height:  return 0
        n = len(height)
        max_left = height[0] #左边的最大值，实时更新
        max_right = height[n-1] #右边的最大值，实时更新
        left,right = 0,n-1 #左右双指针
        water = 0 #储水量
        while left <= right: 
            max_left = max(max_left,height[left]) #每个点都更新，保证是最大值
            max_right = max(max_right,height[right]) #从外向内更新
            if max_left < max_right: #小的一边决定储水量的多少，左边较低，说明
                                     #左边能储存的水最多就这些了，更新左边值，移动指针
                water += max_left - height[left]
                left += 1
            else:
                water += max_right -height[right] #右边较低，说明右边存储的水最多就这些
                right -= 1
        return water

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

时间复杂度：O（n）
栈方法

class Solution():
    def trap(self,height):
        n = len(height)
        #边界条件，小于3个柱子的时候是无法存水的
        if n < 3: return 0
        stack = []#准备构建递减栈
        water = 0
        i = 0
        while i < n:
            #看似双循环，但内层循环是用来做条件判断的
            #只有当栈不为空，且出现上升趋势的时候才进入内循环
            while stack and height[i] > height[stack[-1]]:
                top = stack.pop()#pop栈顶值，要存水的低洼处。#pop加括号！别漏了！查这个bug查半天
                if not stack: break#如果pop后，栈空了就跳出去，继续建栈，这种情况出现在开头两个递增的柱子
                h = min(height[stack[-1]],height[i])-height[top]#高度是左右边界最小值减去低洼处的高度
                dist = i-stack[-1]-1#确定左右边界的距离
                water += h*dist#确定存水值
            #构建递减栈
            stack.append(i)
            i = i+1
        return water

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

时间复杂度：O（n）

leetcode66.加一

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

输入：digits = [1,2,3]
输出：[1,2,4]
解释：输入数组表示数字 123。
1
2
3

示例 2：

输入：digits = [4,3,2,1]
输出：[4,3,2,2]
解释：输入数组表示数字 4321。
1
2
3

示例 3：

输入：digits = [0]
输出：[1]
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/plus-one
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
转数字

#python技巧
#
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        nums = [i*10**index for index,i in enumerate(digits[::-1])]
        nums += 1
        return [int(x) for x in str(nums)]

1
2
3
4
5
6
7
8

时间复杂度：O（n）
判断进位

# 判断特殊情况
#
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(len(digits)-1,-1,-1):
            if digits[i] is not 9:
                digits[i] += 1
                return digits
            else:
                digits[i] = 0
                if digits[0] == 0:
                    digits.insert(0,1)
                    return digits


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

leetcode88.合并两个有序数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。
请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。
注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。
示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
1
2
3
4

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
1
2
3
4

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。
1
2
3
4
5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
双指针 / 从后往前

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        p1 = m - 1
        p2 = n - 1

        p = m + n - 1

        while p1 >= 0 and p2 >= 0:
            if nums1[p1] < nums2[p2]:
                nums1[p] = nums2[p2]
                p2 -= 1
            else:
                nums1[p] = nums1[p1]
                p1 -= 1
            p -= 1

        nums1[:p2 + 1] = nums2[:p2 + 1]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

时间复杂度：O(n+m)
空间复杂度：O(1)
双指针 / 从前往后

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        nums1_copy = nums1[:m]
        nums1[:] = []

        p1 = 0
        p2 = 0

        while p1 < m and p2 < n:
            if nums1_copy[p1] < nums2[p2]:
                nums1.append(nums1_copy[p1])
                p1 += 1
            else:
                nums1.append(nums2[p2])
                p2 += 1

        if p1 < m:
            nums1[p1 + p2:] = nums1_copy[p1:]
        if p2 < n:
            nums1[p1 + p2:] = nums2[p2:]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

时间复杂度：O(n+m)
空间复杂度：O(m)

leetcode189.轮转数组

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

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]
1
2
3
4
5
6

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]
1
2
3
4
5

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/rotate-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
切片

# python技巧
# 超85%
class Solution:
    def rotate(self,nums,k):
        n = len(nums)
        k = k % n
        nums[:] = nums[n-k:] + nums[:n-k]

1
2
3
4
5
6
7
8

pop insert

#python技巧
class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        k = k % len(nums)
        for i in range(k):
            temp = nums.pop()
            nums.insert(0,temp)
        return nums

1
2
3
4
5
6
7
8
9
10
11
12

leetcode283.移动零

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
1
2

示例 2:

输入: nums = [0]
输出: [0]
1
2

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/move-zeroes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class Solution():
    def moveZeroes(self, nums: List[int]) -> None:
	    slow,fast = 0,0
	    for fast in range(len(nums)):
	    	if nums[fast] != 0:
	    		nums[slow],nums[fast] = nums[fast],nums[slow]
	    		slow += 1        

1
2
3
4
5
6
7
8

class Solution():
    def moveZeroes(self, nums: List[int]) -> None:
	    for num in nums:
	    	if num == 0:
	    		nums.remove(0)
	    		nums.append(0)
	    return nums      

1
2
3
4
5
6
7
8