【力扣刷题——数组整理】附力扣链接、题目描述、解题方法及代码（704、35、34、69、367、27、26、283、844、977、209、904、59、54）后续补充

已于 2022-08-17 21:31:37 修改
阅读量308 收藏
点赞数 2
分类专栏： 算法-刷题 文章标签： leetcode 算法 数据结构
于 2022-05-03 14:46:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_47540091/article/details/124550815
版权

😀如果对你有帮助的话😊
🌺为博主点个赞吧 👍
👍点赞是对博主最大的鼓励😋
💓爱心发射~💓

数组

704. 二分查找——简单

力扣

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

二分法

class Solution {
    public int search(int[] nums, int target) {
        if(target<nums[0]||target>nums[nums.length-1]){
            return -1;
        }
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = left + ((right-left)/2);
            if(target == nums[mid]){
                return mid;
            }
            else if(target>nums[mid]){
                left = mid + 1;
            }
            else if(target < nums[mid]){
                right = mid - 1;
            }
            
        }
        return -1;
    }
}

35. 搜索插入位置——简单

力扣

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

请必须使用时间复杂度为 O(log n) 的算法。

示例 1:

输入: nums = [1,3,5,6], target = 5
输出: 2

示例 2:

输入: nums = [1,3,5,6], target = 2
输出: 1

示例 3:

输入: nums = [1,3,5,6], target = 7
输出: 4

class Solution {
    public int searchInsert(int[] nums, int target) {
        int n = nums.length;
        int left = 0;
        int right = nums.length-1;
        while(left<=right){
            int mid = left + ((right-left)/2);
            if(target==nums[mid]){
                return mid;
            }
            if(target>nums[mid]){
                left = mid + 1;
            }
            if(target<nums[mid]){
                right = mid - 1;
            }
        }
        return right + 1;

    }
}

34. 在排序数组中查找元素的第一个和最后一个位置——中等

力扣

给定一个按照升序排列的整数数组 nums，和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。

如果数组中不存在目标值 target，返回 [-1, -1]。

进阶：

  • 你可以设计并实现时间复杂度为 O(log n) 的算法解决此问题吗？

示例 1：

输入：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]

示例 2：

输入：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]

示例 3：

输入：nums = [], target = 0
输出：[-1,-1]

解法1

class Solution {
    public int[] searchRange(int[] nums, int target) {
        if(nums.length == 0) return new int[]{-1,-1};
    
        int l = 0, r = nums.length - 1; //二分范围
        while( l < r)			        //查找元素的开始位置
        {
            int mid = (l + r )/2;
            if(nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if( nums[r] != target) return new int[]{-1,-1}; //查找失败
        int L = r;
        l = 0; r = nums.length - 1;     //二分范围
        while( l < r)			        //查找元素的结束位置
        {
            int mid = (l + r + 1)/2;
            if(nums[mid] <= target ) l = mid;
            else r = mid - 1;
        }
        return new int[]{L,r};
    }
}

解法2

class Solution {
    public int[] searchRange(int[] nums, int target) {
        int leftBorder = searchleft(nums,target);
        int rightBorder = searchright(nums,target);

        if(leftBorder==-2||rightBorder==-2){
            return new int[]{-1,-1};
        }
        if(rightBorder-leftBorder>1){
            return new int[]{leftBorder+1,rightBorder-1};
        }
        return new int[]{-1,-1};
    }

    public int searchleft(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int leftBorder = -2;
        while(left<=right){
            int mid = left + ((right-left)/2);
            if(target<=nums[mid]){
                right = mid - 1;
                leftBorder = right;
            }else{
                left = mid +1;
            }
        }
        return leftBorder;
    }

    public int searchright(int[] nums, int target){
        int left = 0;
        int right = nums.length - 1;
        int rightBorder = -2;
        while(left<=right){
            int mid = left + ((right-left)/2);
            if(target>=nums[mid]){
                left = mid + 1;
                rightBorder = left;
            }else{
                right = mid - 1;
            }
        }
        return rightBorder;
    }
}

69. x 的平方根 ——简单

力扣

给你一个非负整数 x ，计算并返回 x 的 算术平方根

由于返回类型是整数，结果只保留 整数部分 ，小数部分将被 舍去 。

注意：不允许使用任何内置指数函数和算符，例如 pow(x, 0.5) 或者 x ** 0.5 。

示例 1：

输入：x = 4
输出：2

示例 2：

输入：x = 8
输出：2
解释：8 的算术平方根是 2.82842..., 由于返回类型是整数，小数部分将被舍去。

牛顿迭代 三行

class Solution {
    public int mySqrt(int a) {
        long x = a;
        while (x * x > a) x = (x + a / x) / 2;
        return (int)x;
    }
}

二分法

class Solution {
    public int mySqrt(int x) {
        if(x==0) return 0;
        if(x==1) return 1;
        int left = 1;
        int right = x/2;
        while(left < right){
            int mid = left + (right - left+1)/2;
            if (mid >  x/mid ){
                right = mid -1;
            }else{
                left = mid;
            }
        }
        return left;
    }
}

367. 有效的完全平方数——简单

力扣

给定一个 正整数 num ，编写一个函数，如果 num 是一个完全平方数，则返回 true ，否则返回 false 。

进阶：不要 使用任何内置的库函数，如 sqrt 。

示例 1：

输入：num = 16
输出：true

示例 2：

输入：num = 14
输出：false

1、暴力-long

class Solution {
    public boolean isPerfectSquare(int num) {
        long x = 1 , y = 1;
        while(y<= num){
            if(y==num){
                return true;
            }
            ++x;
            y = x * x;

        }
        return false;
    }
}

2、牛顿

class Solution {
    public boolean isPerfectSquare(int num) {
        double x0 = num;
        while(true){
            double x1 = (x0 + num/x0)/2;
            if(x0-x1 < 1e-6){
                break;
            }
            x0 = x1;
        }
        int x = (int) x0;
        return x * x == num;
    }
}

3、二分法-加上long

class Solution {
    public boolean isPerfectSquare(int num) {
        int left = 0;
        int right = num;
        while(left<= right){
            int mid = left + (right - left)/2;
            long square = (long) mid*mid;
            if(square < num){
                left = mid + 1;
            }else if(square > num){
                right = mid -1;
            }else{
                return true;
            }

        }
        return false;
    }
}

27. 移除元素——简单

力扣

给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数，但输出的答案是数组呢?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说，不对实参作任何拷贝
int len = removeElement(nums, val);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

示例 1：

输入：nums = [3,2,2,3], val = 3
输出：2, nums = [2,2]
解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

示例 2：

输入：nums = [0,1,2,2,3,0,4,2], val = 2
输出：5, nums = [0,1,4,0,3]
解释：函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。注意这五个元素可为任意顺序。你不需要考虑数组中超出新长度后面的元素。

1、通用

class Solution {
    public int removeElement(int[] nums, int val) {
        int i = 0;
        for(int x : nums){
            if(x != val){
                nums[i++] = x;
            }
        }
        return i;
    }
}

2、双指针1

class Solution {
    public int removeElement(int[] nums, int val){
        int j = nums.length - 1;
        for(int i=0 ; i<=j; i++ ){
            if(nums[i] == val){
                swap(nums, i--, j--);
            }
        }
        return j+1;
    }

    void swap(int[] nums, int i, int j){
            int b = nums[i];
            nums[i] = nums[j];
            nums[j] = b;
        }
}

3、双指针2

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

26. 删除有序数组中的重复项——简单

力扣

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

判题标准:

系统会用下面的代码来测试你的题解:

int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案

int k = removeDuplicates(nums); // 调用

assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
    assert nums[i] == expectedNums[i];
}

如果所有断言都通过，那么您的题解将被 通过。

示例 1：

输入：nums = [1,1,2]
输出：2, nums = [1,2,_]
解释：函数应该返回新的长度 2 ，并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。

示例 2：

输入：nums = [0,0,1,1,1,2,2,3,3,4]
输出：5, nums = [0,1,2,3,4]
解释：函数应该返回新的长度 5 ， 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。

双指针

class Solution {
    public int removeDuplicates(int[] nums) {
        if(nums == null || nums.length == 0) return 0;
        int a = 0;
        int b = 1;
        while(b < nums.length){
            if(nums[a] != nums[b]){
                nums[a+1] = nums[b];
                a++;
            }
            b++;
        }
        return a+1;

    }
}

283. 移动零

力扣

给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。

请注意 ，必须在不复制数组的情况下原地对数组进行操作。

示例 1:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]

示例 2:

输入: nums = [0]
输出: [0]

双指针

class Solution {
    public void moveZeroes(int[] nums) {
        if(nums==null){
            return;
        }
        int slowIndex = 0;
        for(int fastIndex=0; fastIndex<nums.length;fastIndex++){
            if(nums[fastIndex] != 0){
                int n = nums[fastIndex];
                nums[fastIndex] = nums[slowIndex];
                nums[slowIndex++] = n;
            }
        }
    }
}

844. 比较含退格的字符串——简单

力扣

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

注意：如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

栈

class Solution {
    public boolean backspaceCompare(String s, String t) {
        return build(s).equals(build(t));
    }
    public String build(String str){
        StringBuffer ret = new StringBuffer();   //new 栈
        int length = str.length();  //输入字符串长
        // 判断是否为#
        for(int i =0; i<length; ++i){
            char j = str.charAt(i); //取字符串一位
            // 判断是否为#
            if(j != '#'){
                ret.append(j); // 不为#，入栈
            }else{
                if(ret.length() > 0){
                     ret.deleteCharAt(ret.length() - 1);// 为#，出栈一个
                }
            }
        }
        
        // 返回字符串
        return ret.toString();

    }
}

双指针

class Solution {
    public boolean backspaceCompare(String s, String t) {
        // 双指针
        // 用i，j指针 指向s，t的最后位，从后往前走
        // 用skipS，skipT来表示字符串中#的数量
        // 先判断i，j大于0，
        //      判断字符串中是否为 #，skipS等是否大于0   
        int i = s.length()-1, j = t.length()-1;
        int skipS = 0, skipT = 0;
        while(i>=0 || j>=0){
            while(i>=0){
                if(s.charAt(i) == '#'){
                    skipS++;
                    i--;
                }else if(skipS>0){
                    skipS--;
                    i--;
                }else{
                    break;
                }
            }
            while(j>=0){
                if(t.charAt(j) == '#'){
                    skipT++;
                    j--;
                }else if(skipT>0){
                    skipT--;
                    j--;
                }else{
                    break;
                }
            }
            if(i>=0 && j>=0){
                if(s.charAt(i) != t.charAt(j)){
                    return false;
                }
            }else{
                if(i>=0 || j>=0){
                    return false;
                }
            }
            i--;
            j--;
        }
        return true;
    }
}

977. 有序数组的平方——简单

力扣

给你一个按 非递减顺序 排序的整数数组 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]

暴力

class Solution {
    public int[] sortedSquares(int[] nums) {
        int a = nums.length;
        int[] ans = new int[a];  // 定义数组
        // 循环，做平方
        for(int i =0; i<a; i++){
            ans[i] = nums[i]*nums[i];
        }
        // 数组排序
        Arrays.sort(ans);
        return ans;

    }

双指针

class Solution {
    //双指针
    public int[] sortedSquares(int[] nums) {
        //定义左指针、右指针、存放的数组、数组指针
        int k = nums.length-1;
        int left = 0;
        int right = nums.length-1;
        int[] result = new int[nums.length];
        //循环，大的存数组
        while(left<=right){
            if(nums[left]*nums[left]<nums[right]*nums[right]){
                result[k--] = nums[right]*nums[right];
                --right;
            }else{
                result[k--] = nums[left]*nums[left];
                ++left;
            }
        }
        return result;
    }
}

209. 长度最小的子数组——中等

力扣

给定一个含有 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

滑动窗口

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int left = 0;// 定义数组左
        int sum = 0;// 定义数组右
        int result = Integer.MAX_VALUE; // 定义结果初始值
        // 判断数组左<右
        for(int right=0; right<nums.length; ++right){
            sum += nums[right];//数组的和
            // 循环找最大长度的数组
            while(sum >= target){
                result = Math.min(result,right-left+1);
                sum -= nums[left++];  // 数组的和
            }
        }
        return result == Integer.MAX_VALUE?0:result;
        
    }
}

904. 水果成篮——中等

力扣

你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组 fruits 表示，其中 fruits[i] 是第 i 棵树上的水果 种类 。

你想要尽可能多地收集水果。然而，农场的主人设定了一些严格的规矩，你必须按照要求采摘水果：

  • 你只有 两个 篮子，并且每个篮子只能装 单一类型 的水果。每个篮子能够装的水果总量没有限制。
  • 你可以选择任意一棵树开始采摘，你必须从 每棵 树（包括开始采摘的树）上 恰好摘一个水果 。采摘的水果应当符合篮子中的水果类型。每采摘一次，你将会向右移动到下一棵树，并继续采摘。
  • 一旦你走到某棵树前，但水果不符合篮子的水果类型，那么就必须停止采摘。

给你一个整数数组 fruits ，返回你可以收集的水果的 最大 数目。

示例 1：

输入：fruits = [1,2,1]
输出：3
解释：可以采摘全部 3 棵树。

示例 2：

输入：fruits = [0,1,2,2]
输出：3
解释：可以采摘 [1,2,2] 这三棵树。
如果从第一棵树开始采摘，则只能采摘 [0,1] 这两棵树。

示例 3：

输入：fruits = [1,2,3,2,2]
输出：4
解释：可以采摘 [2,3,2,2] 这四棵树。
如果从第一棵树开始采摘，则只能采摘 [1,2] 这两棵树。

示例 4：

输入：fruits = [3,3,3,1,2,1,1,2,3,3,4]
输出：5
解释：可以采摘 [1,2,1,1,2] 这五棵树。

类似于滑动窗口的多指针解法

class Solution {
    public int totalFruit(int[] fruits) {
        if(fruits.length==0) return 0;
        int first = 0, second = 0, temp =0, result = 0; //初始化
        // 是否有第三种水果
        for(int i =0; i<fruits.length; ++i){
            // 是否有第三种水果
            if(fruits[i] != fruits[first] && fruits[i] != fruits[second]){
                // 当都不相等的时候，判断第一种与第二种一样吗
                if(first != second){
                    first = temp;
                }
                second = i;
            }   
            //更新最大值
            result = Math.max(result,i-first+1);
            if(fruits[temp] != fruits[i]){
                temp = i;
            }

        }
        return result;
    }
}

双指针

class Solution {
    public int totalFruit(int[] fruits) {
        int n = fruits.length;//树的长度
        if(n <= 2) return n;
        int ans = 2,left = 0,right = 0;
        int[] freq = new int[n];//计算篮中每种水果出现的次数。 因为提示中说明了水果的种类数是有限的 0 <= fruits[i] < fruits.length
        int count = 0;//计算数量
        while(right < n){ //右边界小于总数
            freq[fruits[right]]++;//把水果入篮
            if(freq[fruits[right]] == 1) count++; //如果等于1，说明第一次进入篮子，种类数+1
            right++;//继续遍历树
            while(count > 2){//如果当前种类大于2
                freq[fruits[left]]--;//从左边开始对篮子里的水果数量-1
                if(freq[fruits[left]] == 0) count--;// 等于0说明篮中已经没有fruits[left]水果，count减1
                left++;
            }
            ans = Math.max(ans,right-left); //取窗口最大值,窗口里的值，就是在篮子里水果数量的总数
        }
        return ans;
        
    }
}

76. 最小覆盖子串——困难（没写呢）

力扣

59. 螺旋矩阵 II——中等

力扣

给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。

加粗样式

示例 1：

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

示例 2：

输入：n = 1
输出：[[1]]

模拟

class Solution {
    public int[][] generateMatrix(int n) {
        int l=0, r=n-1, b=n-1, t=0;
        int[][] res = new int[n][n];
        int num=1, tar = n*n;
        while(num <= tar){
            for(int i = l; i <= r; i++){
                res[t][i] = num++;
            }
            t++;
            for(int i=t; i<=b; i++){
                res[i][r] = num++;
            }
            r--;
            for(int i=r; i>=l; i--){
                res[b][i] = num++;
            }
            b--;
            for(int i=b; i>=t; i--){
                res[i][l] = num++;
            }
            l++;
        }
        return res;
    }
}

双指针

class Solution {
    public int[][] generateMatrix(int n) {
        int[][] result = new int[n][n];   //定义二维数组
        int x=0,y=0;     //循环圈的起始位置
        int loop = n/2;  //圈循环几次
        int mid = n/2;    //中间坐标
        int offset = 1;     //偏移量
        int count = 1;      //赋值

        while(loop>0){
            //从左到右
            int i = x, j = y; //两个指针
            for(; j < y+n-offset; ++j){
                result[x][j] = count++;
            }

            //从上到下
            for(; i < x+n-offset; ++i){
                result[i][j] = count++;
            }

            //从右到左
            for(; j > y; --j){
                result[i][j] = count++;
            }

            //从下到上
            for(; i > x; --i){
                result[i][j] = count++;
            }
            loop--;

            x += 1;
            y += 1;

            offset+=2;
        }
        if(n%2 == 1){
            result[mid][mid] = count++;
        }
        return result;
    }
}

54. 螺旋矩阵—中等

力扣

在这里插入图片描述
在这里插入图片描述

模拟

class Solution {
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList<Integer>();
        if(matrix==null || matrix.length==0) return res;

        int m = matrix.length;
        int n = matrix[0].length;
        int l=0, r=n-1, t=0, b=m-1;

        while(true){
            for(int i=l; i<=r; i++){
                res.add(matrix[t][i]);
            }
            t++;
            if (t > b) break;
            for(int i=t; i<=b; i++){
                res.add(matrix[i][r]);
            }
            r--;
            if(l > r) break;
            for(int i=r; i>=l; i--){
                res.add(matrix[b][i]);
            }
            b--;
            if (t > b) break;
            for(int i=b; i>=t; i--){
                res.add(matrix[i][l]);
            }
            l++;
            if(l > r) break;
        }
        return res;
    }
}

剑指 Offer 29. 顺时针打印矩阵——简单

力扣

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

示例 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]

顺时针打印矩阵

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        if(matrix.length==0) return new int[0];

        int left = 0, right = matrix[0].length-1;   // 左
        int top = 0, below = matrix.length-1;
        int count = 0;
        int[] result = new int[(right+1) * (below+1)];
        
        while(true){
            // 从左到右
            for(int j = left; j<= right; ++j){
                result[count++] = matrix[top][j];
            }
            if(++top>below) break;

            // 从上到下
            for(int i = top; i<=below; ++i){
                result[count++] = matrix[i][right];
            }
            if(--right<left) break;

            // 从右到左
            for(int j = right; j>= left; --j){
                result[count++] = matrix[below][j];
            }
            if(--below<top) break;

            // 从下到上
            for(int i =below; i>= top; --i){
                result[count++] = matrix[i][left];
            }
            if(++left>right) break;

        }  
        return result;

    }
}
-Blue.
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
LeetCode题目❤分类整理
綦枫Maple的博客
01-25 5819
前言 这是根据LeetCode大佬noone_所编写的《有没有人一起从零开始刷力扣》优化的刷题表格，在原表格的基础上增加了引导链接，点击题目编号即可打开对应的题目。 笔者也在刷，所以目前是刷一块维护一块，也算是督促自己学习。 先按列表刷一遍，如果遇见其他好的题目我也会增添在里面。 感谢noone_大佬用心维护了这样一份刷题列表，对学习的帮助很大。 简介 是不是有许多小伙伴在刷力扣的时候感觉无从下手？从头按顺序开始刷的童鞋们可能会比较有感触，为什么才第四题就感觉很难了?没关系，本文将对力扣的 1-700 题中
力扣刷题(代码回忆录)——数组部分
金州饿霸吃不饱的博客
11-18 1312
力扣刷题(代码回忆录)——数组部分
leetcode刷题——数组
margaret522的博客
02-19 8101
一、二分法 1.leetcode704(简单) 题目链接：https://leetcode-cn.com/problems/binary-search/ 解题思路：题目已知条件是有序，所以考虑二分查找。
【力扣Leetcode】二分查找专题（Python刷题）704，35，69，367，441，33，34，153，162，4
m0_52023710的博客
05-01 697
leetcode刷题，持续更新。python实现二分法，题目：704，35，69，367，441，33，34，153，162，4……
【力扣热题100，个人刷题笔记---中】
weixin_45016269的博客
10-19 253
接上文，为力扣刷题个人笔记。
个人LeetCode刷题记录（带题目链接及解答）持续更新
wxw1437201626的博客
05-27 2237
Leetcode 刷题 注意点; 写代码经常出现的错误总结归纳： 1、for(;;)中的;经常写成， 2、true 的拼写错误 3、while 的离开循环条件忘写，陷入死循环 4、return忘写 5、不能使用关键字命名变量 一些程序的写法： 1、vector排序的写法： Arrays.sort(nums); sort(nums.begin(),nums.end()); 算法思想 1、双指针（7题） 【完成】167.两数之和 II - 输入有序数组 简单 第一代代码（自己想到的） //存在一
LeetCodes刷题总结5——单调栈思想
weixin_53111016的博客
04-25 223
前言 在关于一维数组的各类题目中，存在着一种神奇的思想，它不需要对一个数组来回恶心的遍历，也不需要苦思冥想动态规划方程，这就是单调栈。顾名思义，单调栈是一个栈，需要题目符合先进后出的方式，同时它是单调的，也就是栈里面的元素要么递增，要么递减，一般是边入栈边处理，遇到不单调的情况便进行处理。总之，在我们读取元素是从左到右的，而处理元素是从右到左的，就可以考虑单调栈的思想了。 模板 在这里提前说明，算法题是千变万化的，这个模板只能当作代码的初步骨架或解题思路，是我在一些算法题里总结的，不具有普适性。
LeetCode-刷题记录-二分法合集（本篇blog会持续更新哦~）
喻师傅的学习笔记
07-01 1228
二分法合集（持续更新~）
一段话总结一道题：力扣50~100选
qq_44793993的博客
08-20 227
文章目录
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
力扣刷题力扣刷题力扣刷题力扣刷题
07-16
"力扣刷题"通常指的是用户通过反复练习这些题目来提高自己的编程能力。 在力扣上刷题的过程中，你可以接触到以下几个核心知识点： 1. **数据结构**： - 数组：基础的数据结构，用于存储固定大小的同类型元素集合...
使用力扣刷题的经验.pdf
04-21
在使用力扣平台刷题提升编程和算法能力的过程中，需要把握几个关键的知识点，以及遵循一定的学习方法和策略。 首先，对于编程初学者来说，掌握一门编程语言是进行算法练习的前提。C语言和Java是比较常见的选择，...
力扣刷题总结c++ 解题报告（持续更新中）（csdn）————程序.pdf
12-05
这篇解题报告主要聚焦于C++语言的解决方案，涵盖了多种不同类型的题目，包括但不限于数组操作、字符串处理、链表操作以及数学问题。以下是这些题目及其解法的详细分析： 1. **两数之和** 这是一个基础的哈希表应用...
力扣刷题精选11111
03-23
《力扣刷题精选11111》是针对编程爱好者和准备面试的开发者们的一份宝贵资源，它聚焦于LeetCode平台上的算法题目，涵盖了数据结构与算法、职场技能和职业发展等多个方面。LeetCode作为全球知名的在线编程挑战平台，...
力扣220题详解：存在重复元素 III 的多种解法与复杂度分析
最新发布
10年数据\经营分析经验，现任大厂数据分析负责人
08-21 391
本文详细解读了力扣第220题“存在重复元素 III”，通过使用滑动窗口 + 桶排序和滑动窗口 + 有序集合两种方法高效地解决了这一问题，并提供了详细的解释和模拟面试问答。希望读者通过本文的学习，能够在力扣刷题的过程中更加得心应手。
【LeetCode】148. 排序链表
m0_74197695的博客
08-18 942
给你链表的头结点head，请将其按排列并返回。[1,2,3,4]head = [][]你可以在O(n log n)时间复杂度和常数级空间复杂度下，对链表进行排序吗？
一起学习LeetCode热题100道（48/100）
weixin_53224223的博客
08-20 373
7.注意：虽然代码中包含了回溯部分（即减少当前路径和的计数并从prefixSums中删除它），但在本问题中，由于树是无环的，并且我们不需要精确跟踪每条路径，因此这部分是多余的。输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22。输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8。1.这是主函数，接收根节点和目标和作为参数，并返回满足条件的路径数量。
LeetCode128.最长连续序列
方温热的博客
08-17 218
给定一个未排序的整数数组nums，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
力扣刷题：掌握数组、链表、哈希与双指针技巧
在IT编程领域，数组、链表、哈希表和双指针技巧是基础且重要的概念，尤其在算法设计和数据结构的学习中。本文将分别探讨这些主题。 **数组**： 数组是一种线性数据结构，它将具有相同类型的元素存储在连续的内存...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-Blue.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值