代码随想录算法训练营第二天| 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II ，数组总结

977.有序数组的平方

题目：

. - 力扣（LeetCode）

示例 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 <= nums.length <= 104
• -104 <= nums[i] <= 104
• nums 已按 非递减顺序 排序

思路：

1.初始化新数组new_nums，若nums全部正整数，则直接将nums[i]^2按顺序赋给new_nums即可

2.若nums全部为负数，则需要将nums[i]^2按倒序赋给new_nums

3.若数组包含正数和负数，采用双指针法处理，可申请left和right两个指针，分别指向nums头部和尾部，比较nums[left]^2和nums[right]^2，哪个大赋值new_nums，new_nums倒序插入

func sortedSquares(nums []int) []int {
    length := len(nums)
    new_num := make([]int,length)
    if nums[length-1] <= 0 {
        for i, j := length-1, 0; i >= 0; i-- {
            new_num[j] = nums[i] * nums[i]
            j++
        }
    } else if nums[0] >= 0 {
        for k, val := range nums {
            new_num[k] = val * val
        }
    } else {
        left, right := 0, length-1
        for i := length-1; i >= 0 ; i-- {
            if nums[left]*nums[left] >= nums[right] * nums[right] {
                new_num[i] = nums[left] * nums[left]
                left++
            } else {
                new_num[i] = nums[right] * nums[right]
                right--
            }
        }
    }
    return new_num

}

注意：

go语言切片初始化语法，需要有初始化长度， new_num := make([]int,length)

209.长度最小的子数组

题目：. - 力扣（LeetCode）

给定一个含有 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.采用滑动窗口，就是不断的调节子序列的起始位置和终止位置，从而得出要想的结果

2.不断调整右边 j 的位置，找到一组比target大的子数组 “x”

3.固定右边 j 的位置，找"x"的满足条件的子数组，开始滑动左边 i 的位置，将(sum - nums[i] )与target比较，若仍比target大，则说明找到了一组更小的满足条件的子数组

4.直到(sum-nums[i]) < target，跳出内层循环，j++，继续外层循环

func minSubArrayLen(target int, nums []int) int {
    i, j := 0, 0
    ml := len(nums) + 1  //ml初始化为不可能返回的数，若最终没被修改，则总和依然小于target
    sum := 0
    for l := 0;j < len(nums); {
        sum += nums[j]
        if sum < target {
            j++
        } else {
            //找到一组比target大的数组
            l = j - i + 1
            ml = min(ml, l)
            //不断缩小i，直到sum<target,再跳出，继续移动j
            for sum >= target {
                //缩小i后，若sum仍>=target,子数组长度-1，直到sum<target
                l = j - i + 1
                ml = min(ml, l)            
                sum -= nums[i]
                i++               
            }
            j++
        }
    }
    if ml == len(nums) + 1 {
        return 0
    }  
    return ml
}

func min(x int ,y int) int {
    if x < y {
        return x
    } else {
        return y
    }
}

注意：

1.每次缩" i "以后，要比较当前子数组长度和之前记录的最小长度，取更小的那个值

59.螺旋矩阵II

题目：. - 力扣（LeetCode）

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

示例:输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]

示例 1：

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

示例 2：

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

思路：

1.考察数组基本语法操作，初始化count, count++赋值给数组

2.发现大循环次数等于n/2,比如n=3时，循环1次，最后加上n[1][1]，n=4时，循环2次，n=5时，循环2次再加上n[2][2]

3.每一个大循环中，需要将矩形的四条边赋值，顺时针看，第一条边，i不动，j递增，第二条边，j=n-1,i递增，依此类推

4.注意循环不变量，设置左闭右开区间，第一条边中，假设n=5, 末尾值下标为n-1=4，需要对下标为0到（n-2）进行赋值，因此设置 "j < n-1"(即n-offset)，而不是" j <= n-1"

5.代码不够简洁，冗余有点多（后面再优化吧）

func generateMatrix(n int) [][]int {
    matrix := make([][]int, n)
    for i := 0; i < n; i++ {
        matrix[i] = make([]int, n )  //注意：不能用 “:=”
    }
    ti := n / 2
    startx, starty := 0, 0
    count := 0
    offset := 1
    //x控制循环次数
    for x := 0; x < ti; x++ {
        for j := starty; j < n - offset; j++ {
            count++
            matrix[startx][j] = count
        }
        for i := startx; i < n - offset; i++ {
            count++
            matrix[i][n-offset] = count
        }
        for j :=  n-offset; j > starty; j-- {
            count++
            matrix[n-offset][j] = count
        }
        for i := n-offset ; i > startx; i-- {
            count++
            matrix[i][starty] = count
        }
        offset++
        startx++
        starty++
    }
    if n % 2 == 1 {
        count++
        matrix[n/2][n/2] = count
    }
    return matrix

}

注意：

二维数组初始化matrix[i] = make([]int, n) 而不是“:=”，初始化二维数组时，不能在声明中使用:=操作符，而应该使用赋值操作符=

数组总结 

待补充