代码随想录第二天1.25

1、有序数组的平方

（一）题目

给你一个按 非递减顺序 排序的整数数组 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：直接算出数组的平方后快速排序（有点问题，先放着）

int huafen(int* nums,int low,int high){
    int temp=nums[low];
    while(low<high){
        while(nums[high]>=temp&&low<high) high--;
        nums[low]=nums[high];
        while(nums[low]<=temp&&low<high) low++;
        nums[high]=nums[low];
    }
    nums[low]=temp;
    return low;
}
void QuickSort(int* nums,int low,int high){
    int b;
    if(low<high){
        b=huafen(nums,low,high);
        QuickSort(nums,low,b-1);
        QuickSort(nums,b+1,high);
    }
}

 //先都平方再排序
int* sortedSquares(int* nums, int numsSize, int* returnSize) {
    int j=0;
    if(*returnSize==0) return nums;
    for(int i=0;i<numsSize;i++){
        nums[j]=nums[i]*nums[i];
        j++;    }
    //快排
    QuickSort(nums,0,*returnSize-1);
    return nums;
}

法2：最大值在数组两端，设置两个指针，一头一尾，取大的数值放在尾部

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int k = nums.size() - 1;
        vector<int> result(nums.size(), 0);
        for (int i = 0, j = nums.size() - 1; i <= j;) { // 注意这里要i <= j，因为最后要处理两个元素
            if (nums[i] * nums[i] < nums[j] * nums[j])  {
                result[k--] = nums[j] *nums[j];
                j--;
            }
            else {
                result[k--] = nums[i] * nums[i];
                i++;
            }
        }
        return result;
    }
};

2、长度最小的子数组

（一）题目：

给定一个含有 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：暴力求解

//c语言这个版本数组数字过大超时
int minSubArrayLen(int target, int* nums, int numsSize) {
    int minlength=999,temp=nums[0],length=0;
    for(int i=0;i<numsSize;i++){
        temp=nums[i];
        for(int j=i+1;j<numsSize+1;j++){
            if(temp>=target){ 
                length=j-i;
                if(length<minlength) minlength=length;
                }
            if(j<numsSize) temp=temp+nums[j];       
        }
    }
    if(minlength==999) return 0;
    else return minlength;
}

法2：双指针法

//暂时还没debug出来

3、螺旋矩阵

（一）题目：

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

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

示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

（二）题解：

注意边界！如果刚开始选择左闭右开就保持，不要变了

过几天 需要再复习一下

int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
    if(!matrixSize) { *returnSize = 0; return NULL;}
    *returnSize = matrixSize * matrixColSize[0];
    int* nums = (int *)malloc(sizeof(int) * (*returnSize));
    int cur = 0, l = 0, t = 0, r = matrixColSize[0] - 1, b = matrixSize - 1;
    while(cur < *returnSize) {
        for(int i = l; cur < *returnSize && i <= r; i++) nums[cur++] = matrix[t][i]; t++;
        for(int i = t; cur < *returnSize && i <= b; i++) nums[cur++] = matrix[i][r]; r--;
        for(int i = r; cur < *returnSize && i >= l; i--) nums[cur++] = matrix[b][i]; b--;
        for(int i = b; cur < *returnSize && i >= t; i--) nums[cur++] = matrix[i][l]; l++;
    }
    return nums;
}