力扣977,209,59
写在前面:
昨日疑问可解,随想录说了,这里还是说一下,大家不必太在意leetcode上执行用时,打败多少多少用户,这个就是一个玩具,非常不准确。
哈哈哈哈,懂了,有道理,看来分析复杂度还是王道!!!
一、有序数组的平方
学习文章链接:代码随想录 (programmercarl.com)
力扣链接:977. 有序数组的平方 - 力扣(LeetCode)
题目内容:
给你一个按 非递减顺序 排序的整数数组 nums
,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序
例1:
输入:nums = [-4,-1,0,3,10] 输出:[0,1,9,16,100] 解释:平方后,数组变为 [16,1,0,9,100] 排序后,数组变为 [0,1,9,16,100]
1.第一想法:
先暴力,依次保存i^2到原数组,接着排序就好,用快排,这样时间复杂度o(nlgn)
2.随想录后的思考与收获:
有道理,其实两边的绝对值是最大的,因此可以设置两个指针,一头一尾,比大小放入结果数组里!!!
3.自己实现过程中的困难:
发现还是细节上没把握好,比如开辟空间的,笔试直接定义,现在必须开辟空间,方法不能忘记。
int *answer=(int *)malloc(sizeof(int)*numsSize);
其实这个也常用,只是这个写法要更加适应才行!!!
4.代码
4.1 暴力(测了,也还行)
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* sortedSquares(int* nums, int numsSize, int* returnSize){
*returnSize=numsSize;
int* answer = (int*)malloc(sizeof(int) * numsSize);
for(int i=0;i<numsSize;i++){
answer[i]=nums[i]*nums[i];
}
quicksort(answer,0,numsSize-1);
return answer;
}
void quicksort(int *a,int left,int right)
{
if(left>right)
{
return ;
}
int i=left;
int j=right;
int key=a[left];
while(i!=j)
{
while(a[j]>=a[left]&&i<j)
{
j--;
}
while(a[i]<=a[left]&&i<j)
{
i++;
}
int s;
s=a[i];
a[i]=a[j];
a[j]=s;
}
a[left]=a[i];
a[i]=key;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
4.2 双指针
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* sortedSquares(int* nums, int numsSize, int* returnSize){
*returnSize=numsSize;
int low=0,high=numsSize-1;
int l2,r2;
int* answer = (int*)malloc(sizeof(int) * numsSize);
for(int i=numsSize-1;i>=0;i--){
l2=nums[low]*nums[low];
r2=nums[high]*nums[high];//平方比大小,谁大谁先进目标数组
if(l2>r2){
answer[i]=l2;
low++;
}
else{
answer[i]=r2;
high--;
}
}
return answer;
}
5.结果:
暴力大法的:
双指针的:
二、长度最小的子数组
随想录链接:代码随想录 (programmercarl.com)
力扣链接: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
1.第一想法
子数组问题让我想起来动态规划,但是二维数组感觉有点浪费,不会了,看看录吧!学!
我最初有个想法有点傻,就是说先找到比target小的书中最大的数,然后往前或者往后找,但好像不是很好写,算了,继续学滑动窗口。
2.随想录笔记
哦哦哦哦哦,看懂了看懂了,就是让窗口末尾作为循环的序列;
另外一个指针就用来定上界,滑动序列号求和,如果和小于等于target,则继续后移,长度加一;如果添加后大于target,则长度不加1,将前指针往后移,并减掉该数。如此循环一圈。
3.代码:
尝试根据上述思路码出如下:
int minSubArrayLen(int target, int* nums, int numsSize){
int sum=0,min=numsSize;
int length=0,sumi=0;
sum+=nums[0];
for(int i=0;i<numsSize;i++)
sumi+=nums[i];
if(sumi<target)return 0;
for(int high=1,low=0;(high<numsSize);){//(high-low>0)
if(sum<=target){length++;sum+=nums[++high];}
else{
length--;
sum-=nums[low++];
//high--;//达到high不动的程度
}
if(length<min)min=length;
}
return min;
}
所以,好像有点问题,之后再看看,那就先用这个吧:
int minSubArrayLen(int target, int* nums, int numsSize){
int min=INT_MAX,sum=0,left=0,right=0;
for(;right<numsSize;++right){
sum+=nums[right];
while(sum>=target){
int sublength=right-left+1;
min=min<sublength?min:sublength;//谁小选谁
sum-=nums[left++];
}
}
return min==INT_MAX?0:min;
}
4.结果:
5.思考:
求最大值初始化用INT_MIN,求最小值初始化用INT_MAX
还是想说,卡尔的动画真的很棒哈哈哈,可以帮你模拟,算法一目了然!!!
三、螺旋矩阵
随想录:代码随想录 (programmercarl.com)
这个好像在剑指offer里也有看到,题目如下:
你一个正整数 n
,生成一个包含 1
到 n2
所有元素,且元素按顺时针顺序螺旋排列的 n x n
正方形矩阵 matrix
。
输入:n = 3 输出:[[1,2,3],[8,9,4],[7,6,5]]
1.第一
额,是道模拟的题,但是其实不熟练,如何转圈圈填充是一个问题!!
2.第二
看了看卡尔,唔!哦!没全看明白,可能因为不是很清醒,看不懂了,先模拟一下吧!插个眼,回来学!!
3.代码:
这个模拟不简单,建议看看视频!!!(俺就一下写不出来。。。)
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
int** generateMatrix(int n, int* returnSize, int** returnColumnSizes){
*returnSize = n;
*returnColumnSizes = (int*)malloc(sizeof(int) * n);
//初始化返回结果数组ans
int** ans = (int**)malloc(sizeof(int*) * n);
int i;
for(i = 0; i < n; i++) {
ans[i] = (int*)malloc(sizeof(int) * n);
(*returnColumnSizes)[i] = n;
}
//设置每次循环的起始位置
int startX = 0;
int startY = 0;
//设置二维数组的中间值,若n为奇数。需要最后在中间填入数字
int mid = n / 2;
//循环圈数
int loop = n / 2;
//偏移数
int offset = 1;
//当前要添加的元素
int count = 1;
while(loop) {
int i = startX;
int j = startY;
//模拟上侧从左到右
for(; j < startY + n - offset; j++) {
ans[startX][j] = count++;
}
//模拟右侧从上到下
for(; i < startX + n - offset; i++) {
ans[i][j] = count++;
}
//模拟下侧从右到左
for(; j > startY; j--) {
ans[i][j] = count++;
}
//模拟左侧从下到上
for(; i > startX; i--) {
ans[i][j] = count++;
}
//偏移值每次加2
offset+=2;
//遍历起始位置每次+1
startX++;
startY++;
loop--;
}
//若n为奇数需要单独给矩阵中间赋值
if(n%2)
ans[mid][mid] = count;
return ans;
}
4.结果:
5.总结
放上卡尔的视频,这个需要好好揣摩的,虽然只是简单的模拟,但是不容易的!
一入循环深似海 | LeetCode:59.螺旋矩阵II_哔哩哔哩_bilibili
笑死,太笨了,飞太慢了!加油加油加油!!!