剑指offer刷题宝典--第5节

已于 2024-05-07 18:41:04 修改
阅读量968 收藏 16
点赞数 37
分类专栏： 算法刷题 文章标签： 模拟 数组 字符串 算法
于 2024-03-25 23:45:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41171614/article/details/137029548
版权

剑指offer刷题宝典--第5节

九、模拟

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

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

class Solution {
    public int[] spiralOrder(int[][] matrix) {
        int row = matrix.length;
        if(row==0) return new int[]{};
        int col = matrix[0].length;
        ArrayList<Integer> res = new ArrayList<>();
        int num = row * col;
        int top = 0;
        int left = 0;
        int bottom = row - 1;
        int right = col - 1;

        while (num >= 1) {
            for (int j = left; j <= right && num >= 1; j++) {
                res.add(matrix[top][j]);
                num--;
            }
            top++;
            for (int i = top; i <= bottom && num >= 1; i++) {
                res.add(matrix[i][right]);
                num--;
            }
            right--;
            for (int j = right; j >= left && num >= 1; j--) {
                res.add(matrix[bottom][j]);
                num--;
            }
            bottom--;
            for (int i = bottom; i >= top && num >= 1; i--) {
                res.add(matrix[i][left]);
                num--;
            }
            left++;
        }
        return res.stream().mapToInt(x -> x).toArray();
    }
}

JZ61 扑克牌顺子 【巧！！！】

要求：空间复杂度 O(1)，时间复杂度 O(nlogn)，本题也有时间复杂度 O(n)的解法

根据题意，此 5 张牌是顺子的 充分条件 如下：

  • 除大小王外，所有牌 无重复 ；
  • 设此 5张牌中最大的牌为 max ，最小的牌为 min （大小王除外），则需满足：
    max - min < 5

复杂度分析：
时间复杂度O(NlogN)=O(5log5)=O(1) ： 其中 N为 nums 长度，本题中N=5 ；数组排序使用 O(NlogN) 时间。
空间复杂度 O(1) ： 变量joker 使用 O(1) 大小的额外空间。

import java.util.*;
public class Solution {
    public boolean IsContinuous(int [] numbers) {
        int n = numbers.length;
        int queen=0;
        Arrays.sort(numbers);
        for (int i = 0; i < n-1; i++) {
            if(numbers[i]==0) queen++;
            else if(numbers[i+1]==numbers[i])
                return false;
        }
        return numbers[n-1]-numbers[queen]<5;
    }
}

JZ67 把字符串转换成整数(atoi)

方法一：遍历法（推荐使用）
在这里插入图片描述

import java.util.*;
public class Solution {
    public int StrToInt (String s) {
        int index = 0;
        int n = s.length();
        int res = 0;

        while (index < n) {
            if (s.charAt(index) == ' ')
                index++;
            else break;
        }
        if (index == n)
            return 0;

        int sign = 1;
        if (s.charAt(index) == '+')
            index++;
        else if (s.charAt(index) == '-') {
            index++;
            sign = -1;
        }
        if (index == n)
            return 0;
        while (index < n && s.charAt(index)<='9' && s.charAt(index)>='0') {
            char ch = s.charAt(index);
            if (res > (Integer.MAX_VALUE -(ch-'0'))/10)
                return sign == 1 ? Integer.MAX_VALUE : Integer.MIN_VALUE;
            res = res * 10 + (ch-'0');

            index++;
        }
        return res*sign;
    }
}

JZ20 表示数值的字符串 【难！！！】

进阶：时间复杂度O(n) ，空间复杂度O(n)

解题思路：

 * 分析：整体分两种
 * A[.[B]][e|EC]   .B[e|EC]
 * 
 * A：整数，可正可负
 * B：整数，只能正
 * C：整数，可正可负
     
数字的格式可以用A[.[B]][e|EC]或者.B[e|EC]表示
其中A和C都是整数（可以有正负号，也可以没有），而B是一个无符号整数
总共有三种形式  A[.[B]][e|EC]    .B[e|EC]     A[e|EC]

class Solution {
    int index;
    int n;

    public boolean isNumber(String s) {
        n = s.length();
        if (n == 0) return false;
        index = 0;

        while (index < n && s.charAt(index) == ' ') {
            index++;
            if (index == n) return false;
        }
        // 判断小数之前的部分
        boolean isNum = scanInteger(s);
        if (index < n && s.charAt(index) == '.') {
            index++;
            // 判断小数之后的部分
            isNum = scanUnsignedInteger(s) || isNum ;
        }
       
        if (index < n && (s.charAt(index) == 'e' || s.charAt(index) == 'E')) {
            index++;
            isNum = isNum && scanInteger(s);
        }
        while (index < n && s.charAt(index) == ' ') {
            index++;
            if (index == n) break;
        }
        return index == n && isNum;
    }

    // 判断带符号整数
    private boolean scanInteger(String s) {
        if (index < n && (s.charAt(index) == '-' || s.charAt(index) == '+')) {
            index++;
        }
        return scanUnsignedInteger(s);
    }

    // 判断无符号整数
    private boolean scanUnsignedInteger(String s) {
        int cur = index;
        while (index < n && s.charAt(index) >= '0' && s.charAt(index) <= '9') {
            index++;
        }
        return index > cur;
    }

}

十、数组

JZ21 调整数组顺序使奇数位于偶数前面(一)

要求：时间复杂度 O(n)，空间复杂度 O(n)

进阶：时间复杂度 O(n^2)，空间复杂度 O(1)

方式二：快慢指针

class Solution {
        public int[] exchange(int[] nums) {
        int n = nums.length;
        int right = 0;
        int left = 0;
        while (right < n) {
            if (nums[right] % 2 != 0) {
                swap(nums, left, right);
                left++;
            }
            right++;
        }
        return nums;
    }

    private void swap(int[] nums, int left, int right) {
        int tmp = nums[left];
        nums[left] = nums[right];
        nums[right] = tmp;
    }
}

JZ81 调整数组顺序使奇数位于偶数前面(二)

思想：快慢指针。

import java.util.*;

public class Solution {

    public int[] reOrderArrayTwo (int[] array) {
        int n = array.length;
        for (int i = 0, j = 0; i < n; i++) {
            if (array[i] % 2 != 0) {
                int tmp = array[i];
                array[i] = array[j];
                array[j++] = tmp;
            }
        }
        return array;
    }
}

JZ39 数组中出现次数超过一半的数字

方式一：

空间复杂度：O(1)，时间复杂度 O(n)

摩尔投票法（Boyer–Moore majority vote algorithm），也被称作「多数投票法」，算法解决的问题是：如何在任意多的候选人中（选票无序），选出获得票数最多的那个。
算法可以分为两个阶段：
对抗阶段：分属两个候选人的票数进行两两对抗抵消
计数阶段：计算对抗结果中最后留下的候选人票数是否有效

思想：【擂主和擂主的个数！！】

候选人(cand_num)初始化为nums[0]，票数count初始化为1。
当遇到与cand_num相同的数，则票数count = count + 1，否则票数count = count - 1。
当票数count为0时，更换候选人，并将票数count重置为1。
遍历完数组后，cand_num即为最终答案。

import java.util.*;
public class Solution {
    public int MoreThanHalfNum_Solution(int [] array) {
        int n = nums.length;
        // candidate擂主
        int candidate = nums[0];
        // 表示擂台上擂主的个数
        int count = 1;
        // 数组中的所有数字开始轮番上擂台进行挑战，每个数字的战斗力均为 1
        // 1、相同势力的数字可以都停留在擂台上
        // 2、不同势力的数字会同归于尽
        for (int i = 1; i < n; i++) {
            // 擂台上没有擂主时,那么当前arr[i]就是擂主
            if (count == 0)
                candidate = nums[i];
            //如果擂台上有擂主，而且和当前擂主同类，则votes+1，否则votes-2
            if (nums[i] == candidate) {
                count++;
            } else {
                count--;
            }
        }
        return candidate;
    }
}

JZ43 整数中1出现的次数

进阶：空间复杂度 O(1) ，时间复杂度 O(lognn)

思路：数位dp
在这里插入图片描述

class Solution {
    public int countDigitOne(int n) {
        int res = 0;
        int base = 1;
        int a = n / 10;
        int b = 0;
        int cur = n % 10;
        while (base<=n) {

            if (cur > 1) {
                res += (a + 1) * base;
            } else if (cur < 1) {
                res += a * base;
            } else {
                res += a * base + (b + 1);
            }

            b += cur * base;
            cur = a % 10;
            a = a / 10;
            base *= 10;
        }
        return res;
    }
}


public class Solution {
    public int NumberOf1Between1AndN_Solution(int n) {
        int res = 0;
        int base = 1;
        while (base <= n) {
            int a = n / base / 10;
            int b = n % base;
            int cur = n / base % 10;
            if (cur > 1) {
                res += (a + 1) * base;
            } else if (cur == 1) {
                res += a * base + b + 1;
            } else {
                res += a * base;
            }
            base *= 10;
        }
        return res;
    }
}

JZ45 把数组排成最小的数

方法一：重载比较的排序（推荐使用）

具体做法：

  • step 1：优先判断空数组的特殊情况。

  • step 2：将数组中的数字元素转换成字符串类型。

  • step 3：重载排序比较为字符串类型的x + y < y + x，然后进行排序。

  • step 4：将排序结果再按照字符串拼接成一个整体。

复杂度分析：

时间复杂度 O(NlogN) ： N 为 nums数组的长度 ；使用内置函数的平均时间复杂度为 O(NlogN) ，最差为 O(N 2 ) 。
空间复杂度 O(N) ： 字符串数组 nums占用线性大小的额外空间。
在这里插入图片描述

public class Solution {
    public String PrintMinNumber(int [] numbers) {
        int n = numbers.length;
        if (numbers.length == 0)
            return "";

        String[] nums = new String[numbers.length];
        for (int i = 0; i < n; i++) {
            // nums[i]=String.valueOf(numbers[i]);
            nums[i] = numbers[i] + "";
        }
        //根据指定比较器产生的顺序对指定对象数组进行排序。
        //此处比较器对象中的泛型和下面参数的类型是一致的，
        //如果不指定泛型，那么下面的参数使用具体类型，会报错
        //nums也是string类型
        //注意要想自定义排序规则，就不能使用基本数据类型int,double ,char
        Arrays.sort(nums, new Comparator<String>() {
            public int compare(String s1, String s2) {
                //compareTo属于字符串方法
                return (s1 + s2).compareTo(s2 + s1);
            }
        });
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < n; i++) {
            res.append(nums[i]);
        }
        return res.toString();
    }
}

JZ49 丑数

在这里插入图片描述

class Solution {
    public boolean isUgly(int n) {
        if (n<=0)
            return false;
        int[] facotrs={2,3,5};
        for (int facotr : facotrs) {
            while (n%facotr==0){
                n=n/facotr;
            }
        }
        return n==1;
    }
}

class Solution {
    // 有序数组直接二分
    public int missingNumber(int[] nums) {
        int left = 0, right = nums.length - 1;
        // 下雨等于
        while(left <= right) {
            // 防溢出的写法，位运算提速，这里注意位运算的优先级问题，需要用括号括起来
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == mid) left = mid + 1;
            else right = mid - 1;
        }
        return left;
    }
}

剑指 Offer 53 - II. 0～n-1中缺失的数字

剑指 Offer 53 - II. 0～n-1中缺失的数字

class Solution {
    // 有序数组直接二分
    public int missingNumber(int[] nums) {
        int left = 0, right = nums.length - 1;
        // 下雨等于
        while(left <= right) {
            // 防溢出的写法，位运算提速，这里注意位运算的优先级问题，需要用括号括起来
            int mid = left + ((right - left) >> 1);
            if(nums[mid] == mid) left = mid + 1;
            else right = mid - 1;
        }
        return left;
    }
}

JZ74 和为S的连续正数序列

方法二：滑动窗口（双指针）

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        int i = 1, j = 2, s = 3;
        while (i < j) {
            if (s == sum) {
                ArrayList<Integer> tmp = new ArrayList<>();
                for (int k = i; k <= j; k++) {
                    tmp.add(k);
                }
                res.add(tmp);
            }
            if (s > sum) {
                s -= i;
                i++;
            } else {
                j++;
                s += j;

            }
        }
        return res;

    }
}


import java.util.*;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> res = new ArrayList<>();
        int i = 1, j = 2;
        int s = 3;
        while (i <= sum / 2) {
            if (s == sum) {
                ArrayList<Integer> tmp = new ArrayList<>();
                for (int k = i; k <= j; k++) {
                    tmp.add(k);
                }
                res.add(tmp);
                s -= i;
                i++;
            } else if (s < sum) {
                j++;
                s += j;
            } else {
                s -= i;
                i++;
            }
        }
        return res;
    }
}

JZ57 和为S的两个数字

import java.util.*;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array, int sum) {
        ArrayList<Integer> res = new ArrayList<>();
        HashMap<Integer, Integer> map = new HashMap();
        int n = array.length;
        for (int i = 0; i < n; i++) {
            //注意此处的操作！！
            int num = sum - array[i];
            if (!map.containsKey(num)) {
                map.put(array[i], i);
            } else {
                res.add(num);
                res.add(array[i]);
                break;
            }
        }
        return res;
    }
}

JZ58左旋转字符串

方法一：三次反转（推荐使用）

class Solution {
    public String reverseLeftWords(String s, int k) {
        int n = s.length();
        char[] chars = s.toCharArray();
        reverse(chars, 0, n - 1);
        reverse(chars, 0, n - k - 1);
        reverse(chars, n - k, n-1);
        return new String(chars);
    }

    private void reverse(char[] arr, int i, int j) {
        while (i < j) {
            char tmp = arr[i];
            arr[i] = arr[j];
            arr[j] = tmp;
            i++;
            j--;
        }
    }
}

JZ75 字符流中第一个不重复的字符

方法一：哈希表+字符串（推荐使用）

具体做法：

  • step 1：准备一个字符串来记录输入的字符流，用哈希表统计每个字符的次数，二者都是全局变量。
  • step 2：在Insert函数中对输入的字符，加到字符串最后，然后统计出现次数。
  • step 3：在FirstAppearingOnce函数遍历该字符串，对于每个字符查找哈希表，返回第一个计数为1的字符，如果遍历完字符串以后都没，则返回#。

JZ14 剪绳子

进阶：空间复杂度 O(1)，时间复杂度 O(n)

方法一：动态规划（推荐使用）

用dp[i]表示长度为i的绳子可以被剪出来的最大乘积

dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));

解题思路：

1、我们想要求长度为n的绳子剪掉后的最大乘积，可以从前面比n小的绳子转移而来
2、用一个dp数组记录从0到n长度的绳子剪掉后的最大乘积，也就是dp[i]表示长度为i的绳子剪成m段后的最大乘积，初始化dp[2] = 1
3、我们先把绳子剪掉第一段（长度为j），如果只剪掉长度为1，对最后的乘积无任何增益，所以从长度为2开始剪
4、剪了第一段后，剩下(i - j)长度可以剪也可以不剪。如果不剪的话长度乘积即为j * (i - j)；如果剪的话长度乘积即为j * dp[i - j]。取两者最大值max(j * (i - j), j * dp[i - j])
5、第一段长度j可以取的区间为[2,i)，对所有j不同的情况取最大值，因此最终dp[i]的转移方程为dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))
6、最后返回dp[n]即可

复杂度分析：

  • 时间复杂度：O(n^2)，两层遍历
  • 空间复杂度：O(n)，辅助数组dp的空间
class Solution {
    public int cuttingRope(int n) {
        int[] dp = new int[n + 1];
        dp[2] = 1;
        // 绳子长度
        for (int i = 3; i < n + 1; i++) {
            // 段数
            for (int j = 1; j < i; j++) {
                dp[i] = Math.max(dp[i], Math.max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }
}

方法二：贪心（扩展思路）

进阶：空间复杂度 O(1)，时间复杂度 O(n)
在这里插入图片描述
具体做法：

  • step 1：按照上述思路，不超过3的直接计算
  • step 2：超过3的不断累乘3，然后number不断减去3，直到最后不超过4。
  • step 3：最后乘上剩余的数字。

import java.util.*;
public class Solution {
    public int cutRope (int n) {
        //不超过3直接计算
        if(n <= 3)
            return n - 1;
        //4比较特殊！！
        if(n==4) return 4;
        int res=1;
        while(n>4){
            res*=3;
            n-=3;
        }
        return res*n;
    }
}

JZ83 剪绳子（进阶版）

进阶：空间复杂度 O(1) ， 时间复杂度 O(logn)

方法一：快速幂+快速乘法
在这里插入图片描述

快速幂
在这里插入图片描述

class Solution {
    int mod = 1000000007;
    public int cuttingRope(int n) {
        if (n <= 3) return n - 1;
        int a = n / 3;
        int b = n % 3;
        if (b == 0) {
            return (int) (pow(3, a) % mod);
        } else if (b == 1) {
            return (int) (2 * 2 * pow(3, a - 1) % mod);
        } else {
            return (int) (2 * pow(3, a) % mod);
        }
    }

    // 非递归形式的快速幂
    public long pow(long base, int count) {
        long res = 1;
        while (count > 0) {
            if ((count & 1) == 1) {
                res = (res * base) % mod;
            }
            base = (base * base) % mod;
            count >>= 1;
        }
        return res;
    }
}

十一、字符串

剑指 Offer 58 - I. 翻转单词顺序

剑指 Offer 58 - I. 翻转单词顺序

class Solution {
    public static String reverseWords(String s) {
        String[] strs = s.trim().split(" ");
        int n = strs.length;
        String res = "";
        for (int i = n - 1; i >= 0; i--) {
            if (strs[i].equals("")) continue;
            res += strs[i];
            if (i != 0)
                res += " ";
        }
        return res;
    }
}

整理不易🚀🚀，关注和收藏后拿走📌📌欢迎留言🧐👋📣
欢迎专注我的公众号AdaCoding 和 Github：AdaCoding123
在这里插入图片描述

AdaCoding
关注
  • 37
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer刷题宝典--第3节
weixin_41171614的博客
03-23 624
剑指offer刷题宝典--第3节，动态规划，回溯，DFS
剑指offer刷题宝典--第1节
weixin_41171614的博客
03-22 1084
剑指offer刷题宝典，重点总结，链表，树
python程序员面试宝典 剑指offer_面试必刷-《剑指offer》刷题小结
weixin_39712724的博客
11-24 269
目录写在前面正文数据结构类题目具体算法类题目组队学习写在前面面试季来了，不管是作为面试者还是以后作为面试官，了解算法这门程序员之间的沟通方式都是非常必要的。找过工作的朋友应该都听说过《剑指offer》，本文主要对我这些天刷过的《剑指offer》做个简单的分类小结，方便后面专项复(练)习~正文笔者是NLP方向，这两篇相关方向的面经写得很不错：如果您是高分段选手，看完觉得不用刷题，请点(x)然后私信我...
【剑指offer-第二版】部分题目与解答【C++版本】
m0_37950361的博客
06-12 7395
20180612 求职在即，《剑指offer》作为大家都推荐的一本应试宝典，确实也有刷一刷的必要。很多题目都比较经典，也涵盖了大多数的算法和数据结构。把自己刷题的过程做一个总结，权当是一个笔记。 我自己使用的《剑指offer》第二版，所以题目顺序也按照第二版书上的顺序。 如果是牛客网上面《剑指offer》专题上面有的题目，给出的代码都能够AC通过，但如果是没有的题目，就只做了几个简单...
剑指offer解题笔记
Cybenko
06-17 674
求职在即，《剑指offer》作为大家都推荐的一本应试宝典算法相关资料，确实也有刷一刷的必要。很多题目都比较经典，也涵盖了大多数的算法和数据结构。把自己刷题的过程做一个总结，权当是一个笔记。 下面为本人在LeetCode上面刷的题目笔记，给出所有代码为本人提交Accepted后记录。 数组中重复的数字 题目描述 在一个长度为n的数组里的所有数字都在0到n-1的范围内。 数组中某些数字是重复的，但不知道有几个数字是重复的。也不知道每个数字重复几次。请找出数组中任意一个重复的数字。 例如，如果输入长度为7的数组
字节跳动算法刷题宝典.pdf
zandaoguang的博客
01-03 392
今天推荐一个关于「算法刷题宝典」的开源项目：力扣Cookbook。力扣 Cookbook是@halfrost（中文名：霜神）去年刷的 力扣整理出的 520 题，每道题都写了解题思路，并且...
【Code】剑指offer 03数组中重复的数字
图挖掘领域，新晋砖家 ☞ 未来可期，欢迎和静静一起学习交流吖
07-25 494
LeetCode
【剑指offer-Java版】01为了准备面试也为了提升编程技巧开始刷宝典了
流动的城市的博客
04-25 759
剑指offer算是一本比较经典的面试书籍了，主要从面试技巧到编程能力两个方面，给很多应届求职的学生很多启发。本科的时候就看过这本书，但是没有怎么实践，主要是当时没有找工作，现在又要找工作了，所以把这本经典翻翻。因为最近大半年都是在用Java，工作也是Java研发相关的，所以就用Java实现了一下书中的程序。平均每天5-10题，花了一个星期。因为书比较经典，而且上面的面试题也是可以在网上找得到的，所以
算法刷题宝典.pdf
weixin_44747933的博客
11-20 651
今天推荐一个关于「算法刷题宝典」的开源项目：力扣Cookbook。力扣 Cookbook是@halfrost（中文名：霜神）去年刷的 力扣整理出的 520 题，每道题都写了解题思路，并且...
leetcode中文版-CodeSolutions:我的书籍、课程和实践网站的代码解决方案
06-29
leetcode中文版 ...《剑指Offer》练习题 Course practice 中国大学MOOC 程序设计入门——C语言-浙江大学-翁恺的MOOC网站上的测试题 Python网络爬虫与信息提取-北京理工大学-嵩天的课程练习代码 数据结
面试心得与总结---BAT、网易、蘑菇街
m0_67698950的博客
03-16 271
之前实习的时候就想着写一篇面经，后来忙就给忘了，现在找完工作了，也是该静下心总结一下走过的路程了，我全盘托出，奉上这篇诚意之作，希望能给未来找工作的人一点指引和总结， 也希望能使大家少走点弯路 ， 如果能耐心读完，相信对你会找到你需要的东西。 先说一下LZ的基本情况，LZ是四川某985学校通信专业的研究生（非计算机），大学阶段也就学了C语言，根本没想过最后要成为码农。大四才开始学java，研一下开始学android，所以LZ觉得自己开始就是一个小白，慢慢成长起来的。 一、心态 心态很重要！ ..
【2020校招总结】接受社会的毒打，收获腾讯天美、字节跳动、网易互娱、华为等offer（开发岗）
チン昶的博客
10-22 5244
总结大半年校招经历，希望帮助更多今后想从事软件开发岗的应届同学。
找工作必备书籍推荐-----软件开发
sherry_unique的博客
12-01 1235
程序员必读书籍推荐
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 901
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 688
四、实验结果。
C语言：刷题笔记
weixin_45930573的博客
09-04 414
c语言刷题记录
树状数组记录
最新发布
volcan的博客
09-06 625
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 381
力扣刷题--1534. 统计好三元组【简单】
"剑指Offer刷题：二维数组中查找问题解析
而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维数组的特点是每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值