刷题day1--数组1

最新推荐文章于 2024-08-08 15:12:59 发布

阿苏拉则_妫

最新推荐文章于 2024-08-08 15:12:59 发布

阅读量1.9k

点赞数 50

分类专栏： leetcode 文章标签：算法 python

本文链接：https://blog.csdn.net/sinat_41341777/article/details/138590926

版权

leetcode 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

数组理论基础
1、二分查找
2、移除元素
3、有序数据的平法
4、长度最小的子数组
5、螺旋矩阵II
总结

数组理论基础

数组是在连续内存地址空间上的有相同类型数据的集合

数组下标都是从0开始的。
数组内存空间的地址是连续的

因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。

二维数组
在这里插入图片描述

1、二分查找

题目：
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

输入: nums = [-1,0,3,5,9,12], target = 9     
输出: 4       
解释: 9 出现在 nums 中并且下标为 4

重点：有序、数组

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        left, right = 0, len(nums) - 1  # 定义target在左闭右闭的区间里，[left, right]

        while left <= right:
            middle = left + (right - left) // 2

            if nums[middle] > target:
                right = middle - 1  # target在左区间，所以[left, middle - 1]
            elif nums[middle] < target:
                left = middle + 1  # target在右区间，所以[middle + 1, right]
            else:
                return middle  # 数组中找到目标值，直接返回下标
        return -1  # 未找到目标值

2、移除元素

要知道数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖

给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

示例 1: 给定 nums = [3,2,2,3], val = 3, 函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。

双指针：（快慢指针）
定义快慢指针

快指针：寻找新数组的元素，新数组就是不含有目标元素的数组
慢指针：指向更新新数组下标的位置

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        # 快慢指针
        fast = 0  # 快指针
        slow = 0  # 慢指针
        size = len(nums)
        while fast < size:  # 不加等于是因为，a = size 时，nums[a] 会越界
            # slow 用来收集不等于 val 的值，如果 fast 对应值不等于 val，则把它与 slow 替换
            if nums[fast] != val:
                nums[slow] = nums[fast]
                slow += 1
            fast += 1
        return slow
## 1.引入库
代码

如下（示例）：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import  ssl
ssl._create_default_https_context = ssl._create_unverified_context

3、有序数据的平法

给你一个按非递减顺序排序的整数数组 nums，返回每个数字的平方组成的新数组，要求也按非递减顺序排序。

示例 1：

输入：nums = [-4,-1,0,3,10]
输出：[0,1,9,16,100]
解释：平方后，数组变为 [16,1,0,9,100]，排序后，数组变为 [0,1,9,16,100]

数组其实是有序的，只不过负数平方之后可能成为最大数了。

那么数组平方的最大值就在数组的两端，不是最左边就是最右边，不可能是中间。

此时可以考虑双指针法了，i指向起始位置，j指向终止位置。

定义一个新数组result，和A数组一样的大小，让k指向result数组终止位置。

如果A[i] * A[i] < A[j] * A[j] 那么result[k–] = A[j] * A[j]; 。

如果A[i] * A[i] >= A[j] * A[j] 那么result[k–] = A[i] * A[i]; 。

代码如下

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        result = [float('inf')]*len(nums)
        i = len(nums)-1
        left, right = 0, len(nums) -1
        while left <= right:
            if (nums[left] ** 2) > (nums[right] ** 2):
                result[i] = nums[left] ** 2

                left += 1
            else:
                result[i] = nums[right] ** 2
                right -= 1
            i -= 1
        return result

4、长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 s ，找出该数组中满足其和 ≥ s 的长度最小的连续子数组，并返回其长度。如果不存在符合条件的子数组，返回 0。

示例：

输入：s = 7, nums = [2,3,1,2,4,3]
输出：2
解释：子数组 [4,3] 是该条件下的长度最小的子数组。

滑动窗口：就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果。----区间探索

本质：双指针
滑动窗口：
1、窗口内容是什么
和>=target 长度最小的连续子数组
2、窗口的移动的起始条件
和大于等于target
3、移动的结束条件是什么？、
fast索引到了最后

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        '''
        滑动窗口：
                1、窗口内容是什么
                    和
                2、窗口的移动的起始条件
                    和大于等于target
                3、移动的结束条件是什么？、
                    fast索引到了最后
        '''
        slow, fast = 0, 0
        sum = 0
        min_len = float('inf')
        while fast < len(nums):
            sum += nums[fast]
            while sum >= target:
                min_len = min(min_len, fast - slow + 1)
                sum -= nums[slow]
                slow += 1
            fast += 1
        if min_len != float("inf"):
            return min_len
        else:
            return 0

5、螺旋矩阵II

保证不同循环过程中条件不变

    def generateMatrix(self, n: int) -> List[List[int]]:
        '''
        循环不变量原则
                画四个边，左闭右开的原则循环

        :param n:
        :return:
        '''
        nums = [[0] * n for _ in range(n)]
        x, y  = 0,0 #起始点
        mid = n // 2 #奇数式是矩阵的中心
        time = n//2 #可以迭代的次数
        count = 1
        for offset in range(1,time + 1): #[1-time]次数循环
            for i in range(y, n - offset):
                nums[x][i] = count
                count += 1
            for i in range(x,n - offset):
                nums[i][n- offset] = count
                count += 1
            for i in range(n - offset, y , -1):
                nums[n-offset][i] = count
                count += 1
            for i in range(n - offset, x, -1):
                nums[i][y] = count
                count += 1

            x += 1
            y += 1
        if n%2 != 0:
            nums[mid][mid] = count
        return nums

总结

方案：

1、二分法
注意点：区间，左闭右闭
2、双指针
注意点：快慢指针，结束条件，指针双向还是同向
3、滑动窗口
注意点：本质也是双指针，指针差之间代表的是什么，结束条件、窗口移动的条件
4、模拟行为
注意点：保证数据的循环不变，循环条件是一致的

阿苏拉则_妫

关注

50
点赞
踩
50

收藏

觉得还不错? 一键收藏
1
评论
刷题day1--数组1

方案：1、二分法注意点：区间，左闭右闭2、双指针注意点：快慢指针，结束条件，指针双向还是同向3、滑动窗口注意点：本质也是双指针，指针差之间代表的是什么，结束条件、窗口移动的条件4、模拟行为注意点：保证数据的循环不变，循环条件是一致的。
复制链接

扫一扫