[Go] LeetCode第二天｜977.有序数组的平方 209.长度最小的子数组 59.螺旋矩阵II

977.有序数组的平方

题目链接: https://leetcode.cn/problems/squares-of-a-sorted-array/
关键词：有序数组

解法一：双指针法

平方后大的元素必然在数组的头或尾

func sortedSquares(nums []int) []int {
    length := len(nums)
    target := len(nums) - 1
    left := 0
    right := len(nums) - 1
    newnums := make([]int, length)  //使用切片，因为并不清楚数组长度，故无法使用（len求出长度后也没用，会报错）
    for left <= right{
        if nums[left] * nums[left] < nums[right] * nums[right]{
            newnums[target] = nums[right] * nums[right]
            right--
        }else{
            newnums[target] = nums[left] * nums[left]
            left++
        }
        target--
    }
    return newnums
}

解法二：暴力法

对原数组直接平方后排序

func sortedSquares(nums []int) []int {
    for index, val := range nums{
        nums[index] = val * val
    }
    sort.Ints(nums)    //go中内置的整型排序
    return nums
}

209.长度最小的子数组

题目链接: https://leetcode.cn/problems/minimum-size-subarray-sum/
关键词：连续子数组

解法一：滑动窗口

利用两个变量控制窗口大小

func minSubArrayLen(target int, nums []int) int {
	result := math.MaxInt32
    sum := 0
	start := 0
	for end := 0; end < len(nums); end++ {
		sum += nums[end]
        for sum >= target {
            if result > end - start + 1{
                result = end - start + 1
            }
            sum -= nums[start]
            start++
        }
	}
    if result == math.MaxInt32{
        return 0
    }
	return result
}

解法二：暴力法

暴力法超时
暴力法思路就是每个连续子数组都算一遍

func minSubArrayLen(target int, nums []int) int {
    result := math.MaxInt32
    for i := 0;i < len(nums); i++{
        sum := 0
        for j := i; j < len(nums); j++{
            sum += nums[j]
            if sum >= target{
                if result > j - i + 1{
                    result = j - i + 1
                }
                break
            }
        }
    }
    if result == math.MaxInt32{
        return 0
    }
    return result
}

59.螺旋矩阵II

题目链接:https://leetcode.cn/problems/spiral-matrix-ii/

解法

此题重在模拟过程，每次按顺时针处理矩阵一圈的四条边（因为是数字增大的规律是顺时针螺旋增加）
处理圈数为 n / 2 （每处理1圈矩阵上下左右都减1，从行角度看，每处理一圈，需要处理的行数就减2，故 n 阶矩阵，需要处理的圈数为 n / 2）

注意：

1. 要判断给的n是奇数还是偶数
2. 处理边时，在左闭右开区间处理，这使得每条边处理流程一致

func generateMatrix(n int) [][]int {
	matrix := make([][]int, n)	//创建二维切片
	for i := 0; i < n; i++ {
		matrix[i] = make([]int, n)
	}
	loop := n / 2
	startX, startY := 0, 0 //记录每圈的起始位置
	offset := 1            //记录当前圈数
	count := 1             //计数
	for loop > 0 {
		//处理上边
		for j := startY; j < n-offset; j++ {
			matrix[startX][j] = count
			count++
		}
		//处理右边
		for i := startX; i < n-offset; i++ {
			matrix[i][n-offset] = count
			count++
		}
		//处理下边
		for j := n - offset; j > startY; j-- {
			matrix[n-offset][j] = count
			count++
		}
		//处理左边
		for i := n - offset; i > startX; i-- {
			matrix[i][startY] = count
			count++
		}
		offset++
		startX++
		startY++
		loop--
	}
	//圈数为奇数时，单独处理
	if n%2 == 1 {
		matrix[startX][startY] = count
	}
	return matrix
}