leetcode题目链接
给你一个按 非递减顺序 排序的整数数组 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]
能写出暴力解法,先计算平方然后再排序。嗯,sort函数真好用。O(n+nlogn)
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int size = nums.size();
for (int i=0; i<size; i++){
nums[i]=nums[i]*nums[i];
}
sort(nums.begin(), nums.end());
return nums;
}
};
根据提示我自己写的双指针解法,能对一部分但是并不完全正确。
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int size = nums.size();
int a = 0;
int b = size - 1;
vector<int> result(nums.size(), 0);
for(int i=size-1; i>0; i--){
if(nums[a]*nums[a]>nums[b]*nums[b]){
result[i] = nums[a]*nums[a];
a++;
}else{
result[i] = nums[b]*nums[b];
b--;
}
}
return result;
}
};
正确解法。时间复杂度为O(n)
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;){
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;
}
};
根据代码随想录的解答修改我自己的答案
class Solution {
public:
vector<int> sortedSquares(vector<int>& nums) {
int size = nums.size();
int k = size - 1;
vector<int> result(nums.size(), 0);
for(int a = 0, b=size-1; b>=a;){//重点:这里需要=号。两个指针可以定义在for循环里(a和b)。终止条件都可以是变量。
if(nums[a]*nums[a]>nums[b]*nums[b]){
result[k--] = nums[a]*nums[a];//学习这种每一步赋值后都要往前一步的写法,即k--
a++;//终止条件的变量可以写在for的函数体里面。
}else{
result[k--] = nums[b]*nums[b];
b--;//同上。
}
}
return result;
}
};
leetcode题目链接
给定一个含有 n 个正整数的数组和一个正整数 s ,找出该数组中满足其和 ≥ s 的长度最小的 连续
子数组,并返回其长度。如果不存在符合条件的子数组,返回 0。示例:
输入:s = 7, nums = [2,3,1,2,4,3] 输出:2 解释:子数组 [4,3] 是该条件下的长度最小的子数组。
我自己看着代码随想录滑动窗口(本质是双指针)解法的那个动态图来写的。能通过leetcode中2,3示例,所以我这个写法得到的结果是从左到右第一个符合条件的子数组,但不是最小子数组。
我一开始看错题目了,我以为要计算的是等于target的最小子数组,其实题目是要大于等于。所以下面我写的代码也不是符合题目要求的。
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int N;
for(int i = 0, j = 0; i<nums.size() - 1;){
//计算i和j之间的数组和(只能用循环计算吗)
N = 0;
for(int a = i; a <= j; a++){
N = N + nums[a];
}
if(N == target){
return j - i + 1;
}
if(N < target){
j++;
}
if(N > target){
i++;
}
if(j > nums.size() - 1){
break;
}
}
return 0;
}
};
抄的代码随想录的暴力解法
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0;
int subLength = 0;
for (int i = 0; i<nums.size(); i++){
sum = 0;
for(int j = i; j<nums.size(); j++){
sum = sum + nums[j];
if(sum >= target){
subLength = j - i + 1;
result = result < subLength ? result : subLength; //这个倒是可以解决我上面那个不能找最小数组的缺陷,但是这个是需要找到全部的组合,估计只能适合暴力解法。
break;
}
}
}
return result==INT32_MAX ? 0 : result;
}
};
代码随想录中,从暴力解法优化来的滑动窗口解法。
//这个滑动窗口代码是从暴力解法优化过来的,很有思考价值
class Solution {
public:
int minSubArrayLen(int target, vector<int>& nums) {
int result = INT32_MAX;
int sum = 0;
int subLength = 0;
int i = 0;//加的
for (int j = 0; j<nums.size(); j++){ //i变成j,外层for循环控制结束位置
sum = sum + nums[j];
while(sum >= target){//把原本if的判断写在了while的执行条件里
subLength = j - i + 1;
result = result < subLength ? result : subLength;
sum = sum - nums[i++];//这里其实做了两件事,一个是动态去掉了滑动窗口的前面一个数组值,即缩小滑动窗口,另一个是将指针i后移。嗯,我发现作者好像很喜欢这种数组里取值再直接加减的写法,确实很简洁,可以学学。
}
//下面注释的是暴力解法
// for(int j = i; j
// sum = sum + nums[j];
// if(sum >= target){
// subLength = j - i + 1;
// result = result < subLength ? result : subLength;
// break;
// }
// }
}
return result==INT32_MAX ? 0 : result;
}
};
leetcode题目链接
给定一个正整数 n,生成一个包含 1 到 n^2 所有元素,且元素按顺时针顺序螺旋排列的正方形矩阵。
示例:
输入: 3 输出: [ [ 1, 2, 3 ], [ 8, 9, 4 ], [ 7, 6, 5 ] ]
有个疑问,二维数组的题目是不是至少都是O(n^2)的时间复杂度?
这个题没有算法,就是纯模拟。重要的是处理四个边界都要坚持左闭右开。循环不变量。
数组这一章学习了二分法和双指针法(滑动窗口实质是双指针)。都可以降低暴力解法的时间复杂度。
代码随想录