代码随想录打卡 Day2

977.有序数组的平方

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

快速排序

func sortedSquares(nums []int) []int {
    //快速排序
    for k,v := range nums{
        nums[k] = v * v
    }
    quickSort(nums,0,len(nums)-1)
    return nums
}

func quickSort(nums []int, left int,right int) {
    if left>=right{
        return //这里终止循环别忘了
    }
    //a是基准数的位置
    i,j := left,right
    num := nums[i] //基准数
    for j>i {
        //先从右边找个比基准数小的数
        for j > i && nums[j] >= num{
            j--
        }
        //从左边找个比基准数大的数
        for j > i && nums[i] <= num{
            i++
        }
        //找到的时候交换位置
        nums[i],nums[j] = nums[j],nums[i]
    }
    nums[i],nums[left] = nums[left],nums[i] //把基准数放在合适的位置
    quickSort(nums,left,i-1)
    quickSort(nums,i+1,right)
}

双指针

func sortedSquares(nums []int) []int {
    sizeNum := len(nums)
    res :=make([]int,sizeNum)
    i,j := 0,sizeNum-1 //定义头尾指针
    k := sizeNum-1
    for j>=i {
        if(nums[i] * nums[i] > nums[j] * nums[j] ){
            res[k] = nums[i] * nums[i]
            i++
            k--
        }else{
            res[k] = nums[j] * nums[j]
            j--
            k--
        }
    }
    return res

}

209. 长度最小的子数组

给定一个含有 n 个正整数的数组和一个正整数 target。找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, …, numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

func minSubArrayLen(target int, nums []int) int {
    i,j:=0,0 //窗口边界
    sum := 0
    length := math.MaxInt
    for j<len(nums){
        sum = sum + nums[j]
        j++
        for sum>=target {
            //调整满足条件的窗口
            if j-i<length {
                length = j - i
            }
            sum = sum - nums[i]
            i++
        }
    }
    if length != math.MaxInt{
        return length
    }
    return 0
}

59. 螺旋矩阵 II

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

func generateMatrix(n int) [][]int {
    left,right,top,bottom := 0,n-1,0,n-1
    res := make([][]int,n)
    for i:=0 ; i<n ; i++{
        res[i] = make([]int,n)
    }
    num := 1
    for num <= n * n {
        //处理上边的数据
        for j := left ; j <= right ;j++{
            res[top][j] = num
            num++  
        }
        top++
        //处理右边的数据
        for j := top ; j <= bottom ; j++{
            res[j][right] = num
            num++
        }
        right--
        //处理下面的数据
        for j := right ; j >= left ; j--{
            res[bottom][j] = num
            num++
        }
        bottom--
        //处理左边的数据
        for j := bottom ; j >= top ; j--{
            res[j][left] = num
            num++
        }
        left++
    }
    return res
}