977. 有序数组的平方

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

示例 1：

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

示例 2：

输入： nums = [-7,-3,2,3,11]
输出： [4,9,9,49,121]

实现思路

1、数组是非递减数组，并且有可能为正数 或者 负数 ，所以它们平方组成的数据 按照非递减顺序 排序 的时候 不会是按照数组的顺序来进行

2、可以使用双指针的方案

3、一个指针指向左边 、一个指针指向右边

4、通过比较这两个指针的平方的大小，将大的数据取出来填充

5、如果左边的数据平方比较大 则取出来 按照从后往前进行填充 ，同时 左指针 + 1 ，

6、如果由边的数据平方比较大 则取出来 按照从后往前进行填充， 同时 右指针 - 1

实现代码

func sortedSquares(_ nums: [Int]) -> [Int] {
        // 初始化数组 用来填充平方数
        var newNums = [Int].init(repeating: 0, count: nums.count)
        
        // 左指针  右指针 初始化
        var left = 0, right = nums.count-1
        
        // 需要填充的数组的填充下标
        var tag = right
        
        // 如果左指针 不等于 右指针 循环继续
        while left <= right {
            //如果左边的数据平方比较大 则取出来 按照从后往前进行填充 ，同时 左指针 + 1
            //如果由边的数据平方比较大 则取出来 按照从后往前进行填充， 同时 右指针 - 1
            if left*left > right*right {
                newNums[tag] = left*left
                left += 1
            } else { 
                newNums[tag] = right*right
                right -= 1
            }
            // 填充完之后 填充位置 -1
            tag -= 1
        }
        
        return newNums
    }

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度 。 如果不存在符合条件的子数组，返回 0 。

 

示例 1：

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

示例 2：

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

示例 3：

输入： target = 11, nums = [1,1,1,1,1,1,1,1]
输出： 0

 

提示：

• 1 <= target <= 109
• 1 <= nums.length <= 105
• 1 <= nums[i] <= 105

实现思路

暴力法：

两个 for 循环进行遍历 ，第一个 for 循环变量 数组 ，第二个 for 循环变量 从这个 位置出发 ，到 和 >= target 的长度 ，取这些长度里面的最小长度。

滑动窗口实现：

可以使用滑动窗口来实现： 1、设置两个指针 ，左指针 left 、右指针 right 2、右指针 right 开始往右边遍历 3、边遍历的时候 边 计算 和 sum 4、如果 sum >= target 5、计算此时的最小长度 6、左边的指针 left 往右边移动 【只要窗口 sum >= target left 一直需要往右边移动 每次移动的时候 sum 都要减去移动的那个值 】

实现代码

func minSubArrayLen(_ target: Int, _ nums: [Int]) -> Int {
        var left = 0 ,right = 0
        var sum = 0
        var length = Int.max
        while right < nums.count {
            sum += nums[right]
            while sum >= target {
                length = min(length, right-left+1)
                sum -= nums[left]
                left += 1
            }
            right += 1
        }
        return length == Int.max ? 0 : length
    }

59. 螺旋矩阵 II

labuladong 题解

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

 

示例 1：

输入： n = 3
输出： [[1,2,3],[8,9,4],[7,6,5]]

示例 2：

输入： n = 1
输出： [[1]]

实现思路

1、我们以顺时针旋转一周来进行考虑， 对于 N 这个整数来说 ，我们可以确认我们需要顺时针旋转 N/2 圈 ，对于N为奇数来说 ， 最后还剩下 nums[mid][mid] 没有进行写入 其中 mid = N/2

2、那么我们现在就只需要考虑顺时针旋转一周如何来设置 nums 数组的 x, y 的下标

3、对于矩阵的四条边，我们首先需要保证每一条边的处理都是一致的，这里我们使用 左闭右开 这样的规则.

代码如下

func generateMatrix(_ n: Int) -> [[Int]] {
        // 初始化 nums 
        var nums = [[Int]].init(repeating: [Int].init(repeating: 0, count: n), count: n)
        
        // 初始化起始坐标 x,y
        var startX = 0 , startY = 0
        // count 表示第一个要填入 坐标的值 ，offset 表示每一次转圈的偏移量
        var count = 1, offset = 1
        // 中间节点的坐标
        let mid = n/2
        
        // 遍历旋转的周数
        for _ in 0..<n/2 {
            // 处理上面边的输入
            while startY < n-offset {
                nums[startX][startY] = count
                count += 1
                startY += 1
            }
            // 处理右面边的输入
            while startX < n-offset {
                nums[startX][startY] = count
                count += 1
                startX += 1
            }
            // 处理下面边的输入
            while startY >= offset {
                nums[startX][startY] = count
                count += 1
                startY -= 1
            }
            // 处理左面边的输入
            while startX >= offset {
                nums[startX][startY] = count
                count += 1
                startX -= 1
            }
            // 循环一周之后 起始坐标的值+1 同时 偏移量+1
            startX += 1
            startY += 1
            offset += 1
        }
        
        // 处理N为奇数的时候 最后一个数值
        if n % 2 == 1 {
            nums[mid][mid] = count
        }
        
        return nums
    }