代码随想录算法训练营第二天| LeetCode 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II

合集 - 代码随想录60天训练营(26)

1.代码随想录算法训练营第二天| LeetCode 977.有序数组的平方 ，209.长度最小的子数组 ，59.螺旋矩阵II 2023-07-27

2.代码随想录算法训练营第三天| LeetCode 203.移除链表元素（同时也对整个单链表进行增删改查操作） 707.设计链表 206.反转链表 2023-07-283.代码随想录算法训练营第一天| LeetCode 704. 二分查找、LeetCode 27. 移除元素2023-07-264.代码随想录算法训练营第四天| LeetCode 24. 两两交换链表中的节点 19.删除链表的倒数第N个节点 142.环形链表II 2023-07-305.代码随想录算法训练营第六天| LeetCode 242.有效的字母异位词 349. 两个数组的交集 1. 两数之和 2023-07-316.代码随想录算法训练营第七天| LeetCode 454.四数相加II 15. 三数之和 18. 四数之和 2023-08-027.代码随想录算法训练营第八天| LeetCode 344.反转字符串 541. 反转字符串II 151.翻转字符串里的单词 2023-08-038.代码随想录算法训练营第九天| 复习字符串和双指针法（看卡哥文章复习）2023-08-039.代码随想录算法训练营第十天| 232.用栈实现队列 225. 用队列实现栈2023-08-0410.代码随想录算法训练营第十一天| 20. 有效的括号 1047. 删除字符串中的所有相邻重复项 150. 逆波兰表达式求值2023-08-0711.代码随想录算法训练营第十三天| 239. 滑动窗口最大值 347.前 K 个高频元素 总结2023-08-0812.代码随想录算法训练营第十四天| 理论基础 递归遍历 迭代遍历 2023-08-0913.代码随想录算法训练营第十五天| 层序遍历 10 ，226.翻转二叉树 101.对称二叉树 2 2023-08-1114.代码随想录算法训练营第十六天| 104.二叉树的最大深度 111.二叉树的最小深度 222.完全二叉树的节点个数2023-08-1115.代码随想录算法训练营第十七天| 110.平衡二叉树 257. 二叉树的所有路径 404.左叶子之和 2023-08-1716.代码随想录算法训练营第十八天| 513.找树左下角的值 112. 路径总和 106.从中序与后序遍历序列构造二叉树 2023-08-1717.代码随想录算法训练营第二十天| 654.最大二叉树 617.合并二叉树 700.二叉搜索树中的搜索 98.验证二叉搜索树 2023-08-2118.代码随想录算法训练营第二十一天| 530.二叉搜索树的最小绝对差 501.二叉搜索树中的众数 236. 二叉树的最近公共祖先 2023-08-2119.代码随想录算法训练营第二十二天| 235. 二叉搜索树的最近公共祖先 701.二叉搜索树中的插入操作 450.删除二叉搜索树中的节点 2023-08-2620.代码随想录算法训练营第二十三天| 669. 修剪二叉搜索树 108.将有序数组转换为二叉搜索树 538.把二叉搜索树转换为累加树 总结2023-08-2621.代码随想录算法训练营第二十四天| 理论基础 77. 组合 2023-08-2622.代码随想录算法训练营第二十五天| 216.组合总和III 17.电话号码的字母组合2023-09-0323. 代码随想录算法训练营第二十七天| 39. 组合总和 40.组合总和II 131.分割回文串2023-09-0324. 代码随想录算法训练营第二十八天| 93.复原IP地址 78.子集 90.子集II 2023-09-0325.代码随想录算法训练营第二十九天| 491.递增子序列 46.全排列 47.全排列 II2023-09-0326. 代码随想录算法训练营第三十天| 51. N皇后 37. 解数独 总结 2023-09-03

收起

977.有序数组的平方

          题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

        文章讲解：https://programmercarl.com/0977.%E6%9C%89%E5%BA%8F%E6%95%B0%E7%BB%84%E7%9A%84%E5%B9%B3%E6%96%B9.html

        视频讲解： https://www.bilibili.com/video/BV1QB4y1D7ep

       卡哥的题目建议：建议大家先独立做题，然后看视频讲解，然后看文章讲解，然后在重新做一遍题，把题目AC，最后整理成今日当天的博客，拓展题目可以先不做。本题关键在于理解双指针思想。 

         做题思路：

         有两种方法，暴力解法和双指针法。非递减顺序就是递增顺序，从小到大排。

       暴力解法思路：就是将数组中的每个数平方后，再按从小到大的顺序排序。C++的sort函数是基于快速排序实现的，函数原型 void sort(first,last)，first是要排序的数组的起始地址，last是结束的地址（最后一个数据的后一个数据的地址）。如果利用迭代器，就可以用sort(a.begin(),a.end())，

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10;
int a[N]; //声明全局数组
int main()
{
    int n; //数组的元素个数为 n 
    cout << "请输入数组的元素个数：" << endl;
    cin >> n;
    cout << "请输入数组：" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i]; //循环输入数组中的元素
    }
    for (int i = 0; i < n; i++)
    {
        a[i] *= a[i];
    }
    sort(a,a+n); //注意：这里没有利用迭代器
    for (int i = 0; i < n; i++)
    {
        cout << a[i] << " "; //循环输入数组中的元素
    }

    return 0;
}

       运行结果：

 

        双指针法思路：

       先看给的数组，nums = [-4,-1,0,3,10]，有负数；再平方后，nums = [16,1,0,9,100]，观察到平方后的数组两边的数比中间的大，所以我们可以考虑从第一个位置向后开始，最后一个位置向前开始，比较谁大，如果最后一个位置的数大的话，那就把这个数存放到新数组中，随着第一个位置和最后一个位置的移动，就能实现排序，有移动的动图，在文章链接里。这个两个位置就可以用双指针解决，其实就是两个变量。

#include <iostream>
using namespace std;
const int N = 10;
int a[N]; //声明全局数组
int main()
{
    int n; //数组的元素个数为 n 
    cout << "请输入数组的元素个数：" << endl;
    cin >> n;
    cout << "请输入数组：" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i]; //循环输入数组中的元素
    }
    for (int i = 0; i < n; i++)
    {
        a[i] *= a[i];
    }
    int result[N];//放排好序的新数组
    int k = n - 1; //新数组的下标为k,因为我们是先把大的数放进新数组，所以k值从n - 1开始
    int first = 0;
    int last = n - 1;
    while (first <= last) //第一个位置的下标肯定比最后一个位置下标小或等于，才合法
    {
        if (a[first] < a[last])
        {
            result[k] = a[last];//最后一个位置比第一个位置大，就把最后一个位置的数放到新数组
            k--; //比较完后，新数组的实际大小减一，更新下标
            last--;//最后一个位置的数放到新数组，最后一个位置向前移动
        }
        else
        {
            result[k] = a[first];//第一个位置比最后一个位置大，
            k--;//比较完后，新数组的实际大小减一，更新下标
            first++;//第一个位置的数放到新数组，第一个位置向后移动
        }
    }
    for (int i = 0; i < n; i++)
    {
        cout << result[i] << " "; //循环输入数组中的元素
    }

    return 0;
}

 

       运行结果：

 

 209.长度最小的子数组

          题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

       文章讲解：https://programmercarl.com/0209.%E9%95%BF%E5%BA%A6%E6%9C%80%E5%B0%8F%E7%9A%84%E5%AD%90%E6%95%B0%E7%BB%84.html

       视频讲解：https://www.bilibili.com/video/BV1tZ4y1q7XE

         卡哥的题目建议：本题关键在于理解滑动窗口，这个滑动窗口看文字讲解 还挺难理解的，建议大家先看视频讲解。  拓展题目可以先不做。 

         做题思路：

         有两种方法，暴力解法和双指针法。

       暴力解法思路：这个题是为了找到和大于某个值的长度最小的连续子数组，所以先找到和大于某个值的子数组集合，再找长度最小的。可以用两层for循环，外层循环先定好从哪个地方开始找子数组，内层循环求和，从下标为0的地方开始找和大于某个值的位置，如果和大于某个值，就先记录下这个位置到外层循环定好的位置之间的长度，后面的位置没有必要寻找了。然后开始下一轮外层循环，同理.......再记录，更新长度；直到外层循环完后，才能把最短长度求出来。所以暴力解法会超时。

#include <iostream>
using namespace std;
const int N = 10;
int a[N]; //声明全局数组
int minSubArrayLen(int a[], int s)
{
    int n = sizeof(a);
    int result = INT32_MAX; // 最终的结果,INT32_MAX是int的最大值，2的16次方 - 1
    int sum = 0; // 子数组的数值之和
    int subLength = 0; // 子数组的长度
    for (int i = 0; i < n; i++) //外层循环
    {
        sum = 0; //每一轮外层循环的时候，重置sum值，为了记录不同i值下的长度
        for (int j = i; j < n; j++) //内层循环
        {
            sum += a[j]; 
            if (sum >= s)//求和，从下标为0的地方开始找和大于某个值的位置
            {
                subLength = j - i + 1; //记录下这个位置到外层循环定好的位置之间的长度
                result = result < subLength ? result : subLength;//如果小于最终长度，那最终长度不变；如果大于最终长度，那更新最终长度
                break;
            }
        }
    }
    return result == INT32_MAX ? 0 : result;//如果result没有被赋值的话，就返回0，说明没有符合条件的子数组
}
int main()
{
    int n; //数组的元素个数为 n 
    cout << "请输入数组的元素个数：" << endl;
    cin >> n;
    cout << "请输入数组：" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i]; //循环输入数组中的元素
    }
    int s;
    cout << "请输入正整数 s :" << endl;
    cin >> s;
    cout << minSubArrayLen(a, s) << endl;
    return 0;
}

     

       运行结果：

 

        双指针法思路：我们为了找到和大于某个值的长度最小的连续子数组，想像在数组上移动着找，刚开始会像暴力解法那样，定好一个起始位置，再移动另一个位置，但是如果两个位置都移动，效率就会提升很多，所以就引出了滑动窗口这个方法。在滑动窗口中，分起始位置和终止位置，终止位置用来找到和大于某个值的连续子数组集合；起始位置用来找最短长度，和暴力解法不同的是，当找到了和大于某个值的连续子数组集合后，就是终止位置暂时不移动了，同时记录下长度，起始位置此时从下标0开始移动，每移动一个位置，就用刚求好的和减去上一个位置的数，为了看还能不能找到更短的长度；如果不能的话，那只能移动终止位置，去重新找和大于某个值的连续子数组集合。同理，直到终止位置移动到数组尾部，且找不到最短长度了，就停止。

#include <iostream>
using namespace std;
const int N = 10;
int a[N]; //声明全局数组
int minSubArrayLen(int a[], int s)
{
    int n = sizeof(a);
    int result = INT32_MAX; // 最终的结果,INT32_MAX是int的最大值，2的16次方 - 1
    int sum = 0; //滑动窗口的数值之和
    int subLength = 0; //滑动窗口的长度
    int i = 0; //滑动窗口起始位置
    for (int j = 0; j < n; j++) 
    {
        sum += a[j];
        // 注意这里使用while，每次更新 i（起始位置），并不断比较子数组是否符合条件
        while (sum >= s) {
            subLength = (j - i + 1); // 取子数组的长度
            result = result < subLength ? result : subLength;
            sum -= a[i]; // 这里体现出滑动窗口的精髓之处，不断变更i（子数组的起始位置）
            i++; //起始位置向后移动
        }
    }
    return result == INT32_MAX ? 0 : result;//如果result没有被赋值的话，就返回0，说明没有符合条件的子数组
}
int main()
{
    int n; //数组的元素个数为 n 
    cout << "请输入数组的元素个数：" << endl;
    cin >> n;
    cout << "请输入数组：" << endl;
    for (int i = 0; i < n; i++)
    {
        cin >> a[i]; //循环输入数组中的元素
    }
    int s;
    cout << "请输入正整数 s :" << endl;
    cin >> s;
    cout << minSubArrayLen(a, s) << endl;
    return 0;
}

 

       运行结果：

 

59.螺旋矩阵II

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

      文章讲解：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html

      视频讲解：https://www.bilibili.com/video/BV1SL4y1N7mV/

     卡哥的题目建议：本题关键还是在转圈的逻辑，在二分搜索中提到的区间定义，在这里又用上了。

     做题思路：

        我感觉这里看视频和文章就能理解，就是要想到矩阵可以是一个正方形，从总共能走的圈数，再从正方形4条边入手，这些边可以当做在一个区间上，写一些区间上的边界的限制条件。结合之前做的题，会想到左闭右闭，左闭右开........

#include <iostream>
using namespace std;
const int N  = 10;
int main()
{
    int n;
    cout << "请输入一个正整数 n：" << endl;
    cin >> n;
    int res[N][N] = { 0 };
    int startx = 0, starty = 0; // 定义每循环一个圈的起始位置,相当于一个坐标（startx, starty)
    int loop = n / 2; // 这个可以画图理解，每个圈循环几次，例如n为奇数3，那么loop = 1 只是循环一圈，矩阵中间的值需要单独处理
    int mid = n / 2; // 矩阵中间的位置，例如：n为3， 中间的位置就是(1，1)，n为5，中间位置为(2, 2)
    int count = 1; // 用来给矩阵中每一个空格赋值
    int offset = 1; // 每一圈右边界向里收缩一位
    int i, j;
    while (loop--)
    {
        i = startx;
        j = starty;

        // 下面开始的四个for就是模拟转了一圈
        // 模拟填充上行从左到右(左闭右开)
        for (j = starty; j < n - offset; j++) //行不变，列变，所以列的初始值一开始为0，右开，右边界值不能取到
        { 
            res[startx][j] = count++;
        }
        // 模拟填充右列从上到下(左闭右开)
        for (i = startx; i < n - offset; i++) //列不变，行变，所以行的初始值一开始为0，右开，右边界值不能取到
        {
            res[i][j] = count++;
        }
        // 模拟填充下行从右到左(左闭右开)
        for (; j > starty; j--) //走到了i, j 的最大值处，不需要设行列的初始值，行不变，列变，列不能比0小
        {
            res[i][j] = count++;
        }
        // 模拟填充左列从下到上(左闭右开)
        for (; i > startx; i--)//走到了 i 的最大值处........
        {
            res[i][j] = count++;
        }

        // 第二圈开始的时候，起始位置要各自加1， 例如：第一圈起始位置是(0, 0)，第二圈起始位置是(1, 1)
        startx++;
        starty++;

        // offset 控制每一圈里每一条边遍历的长度
        offset += 1;
    }

    // 如果n为奇数的话，需要单独给矩阵最中间的位置赋值
    if (n % 2 == 1) 
    {
        res[mid][mid] = count;
    }
    for (int i = 0; i < n; i++) //矩阵为 n*n
    {
        cout << "[";
        for (int j = 0; j < n; j++)
        {
            cout << res[i][j] << " ";
        }
        cout << "]";
        cout << endl;
    }
    return 0;
}

 

      运行结果：

 

最后，数组的总结看一下卡哥的吧。

           文章链接：https://programmercarl.com/%E6%95%B0%E7%BB%84%E6%80%BB%E7%BB%93%E7%AF%87.html