数组 704.二分查找、59.螺旋矩阵II、27.移除元素、977.有序数组的平方、209.长度最小的子数组、904. 水果成篮、76. 最小覆盖子串、1004. 最大连续1的个数 III、3. 无重

最新推荐文章于 2024-09-10 08:28:20 发布
最新推荐文章于 2024-09-10 08:28:20 发布
阅读量47 收藏
点赞数
分类专栏： leetcode刷题 # 数组 文章标签： c++ leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jimaplle/article/details/134066580
版权

704.二分查找

题目链接

（1）文字讲解：https://programmercarl.com/0704.%E4%BA%8C%E5%88%86%E6%9F%A5%E6%89%BE.html
（2）视频讲解：https://www.bilibili.com/video/BV1fA4y1o715
（3）题目链接：https://leetcode.cn/problems/binary-search/

有序数组+无重复元素，考虑二分

看到代码随想录之前的想法

二分只记得基本思路了，但是对于边界处理完全忘记了。主要困惑点在于：

  • r到底等于length-1还是length？
  • while中到底是<还是<=?

看到代码随想录之后的想法

有两种解法，但是思路是不变的，区间是不变量。
（1）如果是[a,b]
那么r=length-1,毕竟你要取到r，让nums[r]有意义。while就是<=，因为这里l=r是有可能的。
此外，每次迭代，l=m+1或者r=m-1，因为如下图：
在这里插入图片描述
这里可以得知，nums[m]在上一轮就check过了，没必要check一遍了，所以为了还是保持左闭右闭，每一轮迭代，l=m+1或者r=m-1。
（2）如果是[a,b）
那么r=length,毕竟取不到r。while就是<，因为这里l=r是不可能的。
此外，每次迭代，l=m+1或者r=m-1，因为如下图：
在这里插入图片描述
nums[m]究竟行不行，其实上一轮就已经check过了。我们还是想要保持左闭右开的空间，那么r就要故意取大1位，这样所有这一半需要被check的都囊括进下一轮中。

本题难点

想明白区间是不变量，推荐画图自己模拟一遍。

代码

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size()-1;
        while(l <= r){
            //int m = l + (r - l)/2
            int m = (l + r)/2;
            if(nums[m] == target){
                return m;
            }else if(nums[m] < target){
                l = m+1;
            }else if(nums[m] > target){
                r = m-1;
            }
        }
        return -1;
    }
};

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0;
        int r = nums.size();
        while(l < r){
            //int m = l + (r - l)/2
            int m = (l + r)>>1;
            if(nums[m] == target){
                return m;
            }else if(nums[m] < target){
                l = m+1;
            }else if(nums[m] > target){
                r = m;
            }
        }
        return -1;
    }
};

59.螺旋矩阵II

题目链接

（1）文字讲解：https://programmercarl.com/0059.%E8%9E%BA%E6%97%8B%E7%9F%A9%E9%98%B5II.html
（2）视频讲解：https://www.bilibili.com/video/BV1SL4y1N7mV/
（3）题目链接：https://leetcode.cn/problems/spiral-matrix-ii/

看到代码随想录之前的想法

模拟题，但是我想的很复杂，控制边界条件很麻烦。

看到代码随想录之后的想法

最重要的是领悟“循环不变量”的思想。
1.绕圈，先分成一圈一圈绕，这样就有了loop这个变量，loop=n/2，记录绕多少圈。
2.一个圈有四个方向，按照题目的说法，一个正方形，先从上边开始从左到右，再从右边开始从上到下，再从下边开始从右到左，最后左边开始从下到上。每一圈都是从左上角开始，那么每一圈就需要更新左上角的坐标。于是有了starx，stary这两个变量，每一圈都++；
3.每一圈，每个方向，都设定成左闭右开，这样for循环的终止条件就是< n-offset，offset是每一次圈缩小的变量，每圈++。
4.在注意一下n如果是奇数，那么最中间的空格需要单独设定，于是有了middle这个变量。

本题难点

规定每一圈左闭右开，严格遵守循环不变量。

代码

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n,vector<int>(n,0));
        int starx=0, stary=0;
        int loop = n/2;
        int middle = n/2;
        int offest = 1;
        int count = 1;
        while(loop--){
            int i = starx;
            int j = stary;

            for(; j < n-offest; j++){
                res[starx][j] = count;
                count++;
            }
            for(; i < n-offest; i++){
                res[i][j] = count;
                count++;
            }
            for(; j > stary; j--){
                res[i][j] = count;
                count++;
            }
            for(; i > starx; i--){
                res[i][j] = count;
                count++;
            }
            offest++;
            starx++;
            stary++;
        }
        if(n%2){
            res[middle][middle] = count;
        }
        return res;
    }
};

27.移除元素

题目链接

（1）文字讲解：https://programmercarl.com/0027.%E7%A7%BB%E9%99%A4%E5%85%83%E7%B4%A0.html
（2）视频讲解：https://www.bilibili.com/video/BV12A4y1Z7LP
（3）题目链接：https://leetcode.cn/problems/remove-element/

看到代码随想录之前的想法

暴力，开一个新数组然后复制和target不一样的。

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        vector<int> res;
        for(int i = 0; i < nums.size(); i++){
            if(val != nums[i]){
                res.push_back(nums[i]);
            }else {
                continue;
            }
        }
        nums = res;
        return res.size();
    }
};

然后才看到不要另开数组，我就没办法了。

看到代码随想录之后的想法

双指针思想。慢指针用来记录需要被更新的target的位置，快指针寻找能够更新的后面的元素。一开始快慢指针同时出发，一旦碰到target，慢指针留下，快指针继续。

本题难点

一个双指针思想。还有一个其实是if(val != nums[fast])。这里我一开始也想到了双指针，但是我会让fast++，slow++，如果nums[i] == target，就只让fast++，nums[i] != target, nums[slow] = nums[target],slow++,fast++.
但是fast不管想不想等都要++，还不如直接让fast顶替i，如果不等于就让nums[slow] = nums[target] slow++，如果相等那就continue。总之这个代码在这个处理上很精巧，我想不到。

代码

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;
        for(int fast = 0; fast < nums.size(); fast++){
            if(val != nums[fast]){
                nums[slow] = nums[fast];
                slow++;
            }
        }
        return slow;
    }
};

977.有序数组的平方

题目链接

（1）文字讲解：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
（2）视频讲解：https://www.bilibili.com/video/BV1QB4y1D7ep
（3）题目链接：https://leetcode.cn/problems/squares-of-a-sorted-array/

看到代码随想录之前的想法

最直观的想法肯定是每个平方之后使用sort函数，但是要求使用O(n)的方法，这样就不行。

看到代码随想录之后的想法

双指针思想。其实如果数组有负数的话，最大的数只可能出现在数组的两边，中间的一定是最小的。所以可以设置两个指针，在数组两端，两个指针都往中间走。开一个新数组存平方后的结果。每次都比较指针的数的平方，哪个大就存在新数组里（倒序），然后往中间移动一位。直到两个指针相遇。

本题难点

最大的数只可能出现在两边，由此想到双指针思想。

代码

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        vector<int> res(nums.size(),0);
        int k = nums.size()-1;
        int i=0,j=nums.size()-1;
        while(k>=0){
            if(nums[i]*nums[i] >= nums[j]*nums[j]){
                res[k] =  nums[i]*nums[i];
                i++;
            }else{
                res[k] =  nums[j]*nums[j];
                j--;
            }
            k--;
        }
        return res;
    }
};

滑动窗口

以下题目都是滑动窗口，需要区分是最大滑动窗口和最小滑动窗口。最大的区别就是，最小滑动窗口跟随i更新,while的check条件是满足题目条件（也就是在while内更新），最大滑动窗口跟随j更新，while的check条件是不满足题目条件（也就是在while外更新），具体请看这个总结：
https://leetcode.cn/problems/fruit-into-baskets/solutions/1437444/shen-du-jie-xi-zhe-dao-ti-he-by-linzeyin-6crr/

209.长度最小的子数组

题目链接

（1）文字讲解：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
（2）视频讲解：https://www.bilibili.com/video/BV1tZ4y1q7XE
（3）题目链接：https://leetcode.cn/problems/minimum-size-subarray-sum/

看到代码随想录之前的想法

1.理解错题目意思了，以为不仅仅元素位置要是连续的，大小也必须是严格递增1或者递减1，所以添加了flag这个判断条件。res这个vector也根本没有存在的必要，不需要存找到的子序列，只需要存长度就行。
2.其实使用了双指针，我设置i就是为了指出子序列开始的位置，但是因为我少考虑了一种情况：我这里设置的其实是从i开始，一直到有满足条件的子序列出现，j结束，然后i=j，开始重复。但是，实际上这样忽略了一个问题，假设这么一个子序列：【2，3，4】，target=6，那么i=0，j=2的时候满足了，i=j，其实答案不是【2，3，4】，而是【3，4】，所以i应该慢慢＋1，而不是直接跳到j的地方。

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int flag = 0;//0 没有状态 1 递增序列 2递减序列
        int sum = nums[0];
        int len = 1, reslen = 100001;
        vector<int> res;
        res.push_back(nums[0]);
        for(int i= 0, j = 1; j < nums.size(); j++){
            if(nums[j] == nums[j-1] + 1){
                if(flag == 0 || flag == 1){
                    flag = 1;
                    sum += nums[j]
                    res.push_back(nums[j]);
                    len++;
                    if(sum >= target){
                        if(len < reslen){
                            reslen = len;
                        }
                    }
                    res.clear();
                    res.push_back(nums[j]);
                    len = 1;
                    sum = nums[j];
                    flag = 0;
                }else if(flag == 2){
                    if(sum >= target){
                        if(len < reslen){
                            reslen = len;
                        }
                    }
                    res.clear();
                    res.push_back(nums[j]);
                    len = 1;
                    sum = nums[j];
                    flag = 0;
                }
            }else if(nums[j] == nums[j-1] -1){
                if(flag == 0 || flag == 2){
                    flag = 2;
                    sum += nums[j]
                    res.push_back(nums[j]);
                    len++;
                }else if(flag == 1){
                    if(sum >= target){
                        if(len < reslen){
                            reslen = len;
                        }
                    }
                    res.clear();
                    res.push_back(nums[j]);
                    len = 1;
                    sum = nums[j];
                    flag = 0;
                }

            }else{
                if(sum >= target){
                        if(len < reslen){
                            reslen = len;
                        }
                    }
                res.clear();
                res.push_back(nums[j]);
                len = 1;
                sum = nums[j];
                flag = 0;
            }
        }
    }
};

然后经过反思我写出了第二版，但是依然错了：

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;
        int len = 100001;
        for(int i=0,j=0; j < nums.size(); j++){
            sum+=nums[j];
            if(sum >= target){
                while(i <= j){
                    if(sum >= target){
                        len = (j-i+1) < len? (j-i+1) : len;
                    }
                    sum -= nums[i];
                    i++;
                }
            }
        }
        return len == 100001? 0 : len;
    }
};

这一版的问题其实和上一版差不多。这一版的想法是i先不动，j增加，直到substr的和已经大于target，j固定住，再来移动i，看看能不能把这个substr缩短。但是我的while条件是i<=j，也就是说，i一直要移动到j的位置上，但是忽略了一种情况就是，i可能移动到一半，substr的和就已经小于target了，如果这题的substr刚好出在此时的i到j+n这一段里面，那么就错了。如下图的案例：
在这里插入图片描述
总之，这样不行。

看到代码随想录之后的想法

滑动窗口的窗口里的条件一定是sum>=target，i，j在哪不重要。

本题难点

理解滑动窗口的判别条件。最小滑动窗口。

代码

class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int sum = 0;
        int len = 100001;
        for(int i=0,j=0; j < nums.size(); j++){
            sum+=nums[j];
            while(sum >= target){
                len = (j-i+1) < len? (j-i+1) : len;
                sum -= nums[i];
                i++;
            }
        }
        return len == 100001? 0 : len;
    }
};

904. 水果成篮

题目链接

https://leetcode.cn/problems/fruit-into-baskets/description/

本题难点

最大滑动窗口。

代码

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        unordered_map<int,int> lz;
        int len = 0;
        for(int i = 0, j= 0; j < fruits.size(); j++){
            lz[fruits[j]]++;
            while(lz.size() > 2){
                auto it = lz.find(fruits[i]);
                it->second--;
                if (it->second == 0) {
                    lz.erase(it);
                }
                i++;
            }
            len = len < (j-i+1) ? j-i+1 : len; 
        }
        return len;
    }
};

76. 最小覆盖子串

题目链接

https://leetcode.cn/problems/minimum-window-substring/

本题难点

最小滑动窗口

代码

class Solution {
public:
    unordered_map<char,int> cnts,cntt;

    bool check() {
        for(auto it=cntt.begin();it!=cntt.end();it++){
            auto its = cnts.find(it->first);
            if(its != cnts.end()){
                if(its->second < it->second){
                    return false;
                }
            }else{
                return false;
            }
        }
        return true;
    }

    string minWindow(string s, string t) {
        int left = 0;
        int len = 100001;
        for(int k = 0; k < t.length(); k++){
            cntt[t[k]]++;
        }
        for(int i = 0, j = 0; j < s.length(); j++){
            cnts[s[j]]++;
            while(check()){
                if(len > j-i+1){
                    len = j-i+1;
                    left = i;
                }
                auto itt = cnts.find(s[i]);
                itt->second--;
                if(itt->second == 0){
                    cnts.erase(s[i]);
                }
                i++;
            }
        }
        if(len != 100001)
        {
            return s.substr(left,len);
        }else{
            return "";
        }
    }
};

1004. 最大连续1的个数 III

题目链接

https://leetcode.cn/problems/max-consecutive-ones-iii/description/

本题难点

最大滑动窗口

代码

class Solution {
public:
    int longestOnes(vector<int>& nums, int k) {
        int sum = 0;
        int len = 0;
        for(int i=0,j=0; j < nums.size(); j++){
            if(nums[j] == 0){
                sum++;
            }
            while(sum > k){
                if(nums[i] == 0){
                    sum--;
                }
                i++;
            }
            len = len > (j-i+1)?len:j-i+1;
        }
        return len;
    }
};

3. 无重复字符的最长子串

题目链接

https://leetcode.cn/problems/longest-substring-without-repeating-characters/

本题难点

最大滑动窗口

代码

class Solution {
public:
    unordered_map<int,int> cnt;
    bool check(){
        for(auto it = cnt.begin(); it != cnt.end(); it++){
            if(it->second >1){
                return false;
            }
        }
        return true;
    }
    int lengthOfLongestSubstring(string s) {
        int len = 0;
        for(int i =0, j =0; j < s.length(); j++){
            cnt[s[j]]++;
            while(!check()){
                auto its = cnt.find(s[i]);
                its->second--;
                if(its->second == 0){
                    cnt.erase(s[i]);
                }
                i++;
            }
            len = len > (j-i+1)?len:(j-i+1);
        }
        return len;
    }
};
H1kemo
关注
专栏目录
Algorithm：【算法进阶之路】之算法面试刷题集合—数组与排序相关算法题(数学问题—两数之和/岛屿的最大面积/岛屿数量/搜索旋转排序数组/寻找两个正序数组的中位数/最长连续递增序列/最长上升子序列
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
08-27 37
​ Algorithm：【算法进阶之路】之算法面试刷题集合—数组与排序相关算法题(数学问题—两数之和/岛屿的最大面积/岛屿数量/搜索旋转排序数组/寻找两个正序数组的中位数/最长连续递增序列/最长上升子序列/数组中的第K个最大元素/链表中倒数第k个节点等) 目录 相关题库 一、数组与排序相关的算法题 相关题库 企业题库(按照考试频率)：CodeTop企业题库 GitHub题库地址：https://github.com/afatcoder/
数组经典题目
qq_33253721的博客
04-29 1019
一、二分查找 题目704.二分查找. 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 题目中的前提条件有： 1.数组为有序数组 2.数组中无重复元素 数组有序是使用二分法的前提，而且如果有重复元素，二分查找返回的元素下标可能不是唯一的，这些都是使用二分法的前提，看到题目满足如上条件时，可以考虑一下是不是可以使用二分法。 二分法的思想虽然简单，但涉及边界条件，需要清楚定义区间，也就是定
数组 | 704.二分查找、27.移除元素、977.有序数组的平方 、209.长度最小的子数组、59.螺旋矩阵II
weixin_43926766的博客
04-07 118
数组平方的最大值就在数组的两端，因此双指针分别指向数组的两端，从两端开始比较两个指针指向元素的大小，较大的一个放入新数组，同时移动指针，之后继续比较直到left>right。由于数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖，因此如果采用暴力解，每删除一个元素就要将后面的所有元素向前移动一位。并且，由于新移动过来的第一个元素放在了刚刚覆盖掉的元素的位置，还没有检查该元素是否需要删除，i的大小需要保持不变，需要添加i--来对冲循环条件中的i++。组成的新数组，要求也按。
Leetcode刷题（数组）| 704. 二分查找；27.移除元素； 977. 有序数组的平方；209. 长度最小的子数组；59. 螺旋矩阵II
weixin_45634447的博客
07-17 106
很早之前就已经了解到了代码随想录，也自己刷了一部分题，但一直没有认真完成过。现在马上秋招，打算按部就班地在重新刷一遍，同时也开个博客记录下来自己的理解，方便以后查看。使用二分查找最重要的是前提是此外还提到了一个思想叫做比如区间取左闭右闭的话，那么每次区间二分，范围都是新区间的左闭右闭 ，后面做判断时 ，要一直基于这个左闭右闭的区间。二分法要注意边界问题：[left, right] 还是 [left, right)。二分法的时间复杂度是 O(logn)。
代码随想录算法学习第一天|704. 二分查找，27. 移除元素，977.有序数组的平方，209.长度最小的子数组，59.螺旋矩阵II | 75.颜色分类
m0_49249434的博客
03-01 1424
循环里面逻辑如下：如果nums不等于val，则将nums[fast]赋值给nums[slow]，然后slow指针后移，最后slow会等于新数组长度。
代码随想录Day2| 977.有序数组的平方209.长度最小的子数组 59.螺旋矩阵II
sRiddle的博客
12-28 437
Day2
一刷随想录第二天打卡（977.有序数组的平方、209.长度最小的子数组 、59.螺旋矩阵II）
2301_76661918的博客
07-04 853
在本题中，螺旋矩阵的构成就是用数字模拟画圈，那么要考虑的问题就是循环的圈数，以及边界的处理问题，此时就要考虑循环中的不变量，即处理边界时开闭问题，每条边界应统一使用一个开闭的原则，如左闭右开等等，原理如下图（摘自代码随想录）其具体思路如下：由于数组是有序的，那么数组内绝对值最大一定在数组两侧其中一侧，设两个指针分别从头尾访问数组，将两侧数进行平方后再比较，将大数按升序放入数组，并向数组的另一侧移动大数对应的指针，重复比较直到两个指针重合。连续就代表可以一组一组的看子数组，而不用关注不连续的序列带来的问题。
算法分析之数组问题
小朱小朱绝不认输的博客
11-30 2545
文章目录一、数组理论基础二、leetcode例题讲解数组问题 一、数组理论基础 数组是非常基础的数据结构。 首先要知道数组在内存中的存储方式：数组是存放在连续内存空间上的相同类型数据的集合。 数组可以方便的通过下标索引的方式获取到下标下对应的数据。 需要两点注意的是： 数组下标都是从0开始的。 数组内存空间的地址是连续的。 正是因为数组的在内存空间的地址是连续的，所以我们在删除或者增添元素的时候，就难免要移动其他元素的地址。 数组的元素是不能删的，只能覆盖。 二维数组在内存的空间地址是连续的么？在Jav
leetCode关于数组的相关题目
dhhh的博客
09-10 349
数组 二分查找 leetCode704 给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。 输入: nums = [-1,0,3,5,9,12], target = 9 输出: 4 解释: 9 出现在 nums 中并且下标为 4 输入: nums = [-1,0,3,5,9,12], target = 2 输出: -1 解
LeetCode 一周小记 No.1
su_rxy的博客
02-24 218
刷的脑壳疼，在螺旋矩阵卡了很久，其他的 easy Level 都也被卡，目前进度为 2-3 medium / day。 Monday （科普知识） 反码、补码 二进制的第一位是符号位，0是+，1是-，如果是1，怎么得到具体数字？ 二进制数全都取反，再+1就是对应结果的的绝对值 。 例如-1的二进制数全为1，则将后31个1全取反并+1，得到 000…1 的十进制数就是1 。 如何把随机出现从 x 概率变为 x^3 概率？ Math.Max(Math.Random(),Math.Max(Math.Rando
【c++23种设计模式概述】
m0_45463480的博客
09-09 721
c++23种设计模式概述。
C语言 | Leetcode C语言题解之第389题找不同
m0_59237910的博客
09-07 760
C语言 | Leetcode C语言题解之第389题找不同
【C++】CLion配置cout打印语句快捷键
最新发布
qq_38196449的博客
09-10 209
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言作用域
天道酬勤
09-07 1003
作用域 (scope) 是描述程序可以访问标识符的区域。块是一对花括号 {} 括起来的区域 或 函数体内任意复合语句定义范围内的区域。定义在块中的变量具有块作用域。块作用域的变量的可见范围从定义处开始到该块定义范围的末尾为止。函数作用域是在整个函数体内可见的意思，在 C 程序中，函数形参和 goto 语句的标签具有函数作用域，在整个函数体内可见。在所有函数外定义的变量具有全局作用域，在整个程序都可见。在数据类型前加 static 关键字定义的全局变量具有文件作用域。
C语言——strcpy、sprintf与memcpy
鲸落博客
09-09 1137
该函数和printf()函数有很多相似之处，例如printf()将不同类型的数据格式化到终端，而sprintf()函数是将不同类型的数据格式化到字符串中。另外，和strcpy()函数一样，该函数也不会对目标缓冲区进行检查，容易造成溢出。它是一种非常通用的内存复制函数，不仅限于复制字符串，还可以复制任何类型的内存块。3. 未定义行为：程序可能会继续运行，但结果不可预测，可能会输出错误的结果或导致其他未预料的行为。如果memcpy复制字符串，要复制的字节数超过原内存块本身的内存数，会怎么样？
C语言初阶 --- ⾃定义类型：结构体
2301_79842589的博客
09-08 1022
💫往期文章👇：
c++ 类的继承详解
HJQD777的博客
09-07 506
继承允许类之间建立层次关系，促进代码重用和扩展。继承有不同的访问控制方式（publicprotectedprivate），影响派生类对基类成员的访问权限。基类的构造函数和析构函数不会被继承，派生类需要自行定义。使用虚函数和多态可以实现灵活的接口设计和动态方法调用。理解继承机制对于设计高效、灵活和可维护的面向对象系统至关重要。
C++ #include ＜cstring＞（详解）
qq_51753728的博客
09-08 1007
是在 C++ 程序中引入头文件<cstring>的语句。这个头文件提供了用于处理 C 风格字符串（即以空字符'\0'结尾的字符数组）的函数。具体来说，<cstring>（1）strcpystrcpy是cstring中用于复制 C 风格字符串的函数，它将源字符串的内容复制到目标字符串中，包括末尾的空字符 ('\0'使用strcpy时需要确保目标数组有足够的空间来存放源字符串。source。
Java Native Interface (JNI) 简介
goTsHgo的博客
09-09 876
是 Java 提供的一种接口，用于允许 Java 应用程序与本地（Native）代码进行交互。通过 JNI，Java 代码可以调用 C/C++ 等其他语言编写的库，反之亦然。JNI 的主要用途包括：与底层系统库交互、调用高性能本地代码、或使用 Java 不能直接访问的硬件设备。问题：JNI 的常见问题与挑战内存管理问题：问题：Java 使用自动垃圾回收，而 C/C++ 代码需要手动管理内存。这可能会导致内存泄漏、指针错误或空指针访问等问题。共性规律：涉及不同语言的互操作时，内存管理往往是最大的挑战。
二分查找解密：有序旋转数组的最小值问题
在"菜鸡的算法修炼——有序数组的二分查找（剑指offer题目，旋转数组的最小值，Java实现）"这篇文章中，主要讨论了如何在一个非递减排序的数组旋转后找到其最小元素的问题。题目背景设定为，当数组的一部分被移动到...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值