剑指offer刷题总结（53-68）

最新推荐文章于 2023-12-27 00:15:00 发布
最新推荐文章于 2023-12-27 00:15:00 发布
阅读量194 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhaopinglee/article/details/107358389
版权

剑指offer（53-68）

前言

【面试题中的各项能力】

  1. 沟通能力（多提问）
  2. 学习能力
  3. 知识迁移能力
  4. 抽象建模能力
    1. 选择合理的数据结构来表述问题
    2. 分析模型中的内在规律，并用代码表述这种规律
  5. 发散思维能力（多向性、变通性）
53. 数字在排序数组中出现的次数

【题目】

统计一个数字在排序数组中出现的次数。

【思路】

分别用二分查找找到第一个k和最后一个k的下标

public class Solution {
    public int GetNumberOfK(int [] array , int k) {
        int num = 0;
        if(array == null || array.length == 0){
            return num;
        }
        int left = getFirstK(array, 0, array.length - 1, k);
        int right = getLastK(array, 0, array.length - 1, k);
        if(left > -1 && right > -1){
            return right - left + 1;
        }
        return num;
    }
    
    private int getFirstK(int[] arr, int start, int end, int k){
        if(start > end){
            return -1;
        }
        int mid = start + ((end - start) >> 1);
        if(arr[mid] == k){
            if((mid - 1 > 0 && arr[mid - 1] != k) || mid == 0){  // 【错误处】：未考虑数组越界以及k位于头尾的情况
                return mid;
            }else{
                end = mid - 1;
            }
        }else if(arr[mid] < k){
            start = mid + 1;
        }else{
            end = mid - 1;
        }
        return getFirstK(arr, start, end, k);
    }
    
    private int getLastK(int[] arr, int start, int end, int k){
        if(start > end){
            return -1;
        }
        int mid = start + ((end - start) >> 1);
        if(arr[mid] == k){
            if(mid == arr.length - 1 || (mid + 1 < arr.length && arr[mid + 1] != k)){
                return mid;
            }else{
                start = mid + 1;
            }
        }else if(arr[mid] > k){
            end = mid -1;
        }else {
            start = mid + 1;
        }
        return getLastK(arr, start, end, k);
    }
}
54. 二叉查找树的第 K 个结点

【题目】

给定一棵二叉搜索树，请找出其中的第k小的结点。

例如，（5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。

【思路】
55.1 二叉树的深度

【题目】

从根结点到叶结点依次经过的结点（含根、叶结点） 形成树的一条路径，最长路径的长度为树的深度。

【思路】

将二叉树右旋90度看作尾节点相交的链表 f(n) = g(f(n - 1))

//递归：自底向上（类似动态规划：当前层的深度由下一层决定）
public class Solution {
    public int TreeDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        return Math.max(TreeDepth(root.left), TreeDepth(root.right)) + 1;
    }
}
//回溯：自顶向下
public class Solution {
    private int maxDepth = 0;
    public int TreeDepth(TreeNode root) {
        TreeDepth(root, 0);
        return maxDepth;
    }
    private void TreeDepth(TreeNode root, int depth){
        if(root == null){
            maxDepth = Math.max(depth, maxDepth);
            return ;
        }
        depth += 1;
        TreeDepth(root.left, depth);
        TreeDepth(root.right, depth);
    }
}
55.2 平衡二叉树

【题目】

输入一棵二叉树，判断该二叉树是否是平衡二叉树。在这里，我们只需要考虑其平衡性，不需要考虑其是不是排序二叉树

【思路】
56. 数组中只出现一次的数字

【题目】

一个整型数组里除了两个数字之外，其他的数字都出现了两次。请写程序找出这两个只出现一次的数字。

要求O(N) + O(1)。

【思路】

位运算的运用

相同的两个数的异或结果为 0；

先看简单的情况：假如出现一次的数字只有1个

​ 从头异或，因为两两相消，剩下的就是只出现一次的这个数

再看复杂的情况：如题

  1. 从头异或，剩下的是这两个不同数的异或结果，二进制中出现的 1 都是其中一个数独有的
  2. 任选一个位置的 1，通过判断每个数这个位置上的是否有 1 将所有数分成两组，相同的数自然会分到一起，分成了两个简单的问题
//num1,num2分别为长度为1的数组。传出参数
//将num1[0],num2[0]设置为返回结果
public class Solution {
    public void FindNumsAppearOnce(int [] array,int num1[] , int num2[]) {
        // 找出两数的异或结果
        int bitResult = 0;
        for(int i = 0; i < array.length; i++){
            bitResult ^= array[i];
        }
        
        //找出二进制中一个1的位置
        int index = 0;
        while((bitResult & 1) != 1){
            bitResult = bitResult >> 1;
            index++;
        }
        
        //找出两个数
        num1[0] = 0;
        num2[0] = 0;
        for(int i = 0; i < array.length; i++){
            if(isBit1(array[i], index)){
                num1[0] ^= array[i];
            }else {
                num2[0] ^= array[i];
            }
        }
        
    }
    
    public boolean isBit1(int num, int index){
        num = num >> index;
        if((num & 1) == 1){
            return true;
        }
        return false;
    }
}
57.1 和为 S 的两个数字

【题目】

输入一个递增排序的数组和一个数字S，在数组中查找两个数，使得他们的和正好是S，如果有多对数字的和等于S，输出两个数的乘积最小的。

对应每个测试案例，输出两个数，小的先输出。

【思路】

双指针

初始为 left = 0 与 right = length - 1，

等于 s ，则返回

小于 s ，left++；大于s， right–；保证 left < right

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> FindNumbersWithSum(int [] array,int sum) {
        ArrayList<Integer> result = new ArrayList<>();
        if(array == null || array.length < 2){
            return result;
        }
        int left = 0;
        int right = array.length - 1;
        while(left < right){
            if(array[left] + array[right] == sum){
                result.add(array[left]);   // 【错误处】：不是返回坐标而是这两个值
                result.add(array[right]);
                break;
            }else if(array[left] + array[right] > sum){
                right--;
            }else{
                left++;
            }
        }
        return result;
    }
}
57.2 和为 S 的连续正数序列

【题目】

小明很喜欢数学,有一天他在做数学作业时,要求计算出9~16的和,他马上就写出了正确答案是100。但是他并不满足于此,他在想究竟有多少种连续的正数序列的和为100(至少包括两个数)。没多久,他就得到另一组连续正数和为100的序列:18,19,20,21,22。现在把问题交给你,你能不能也很快的找出所有和为S的连续正数序列? Good Luck!

输出所有和为S的连续正数序列。序列内按照从小至大的顺序，序列间按照开始数字从小到大的顺序

【思路】

双指针，left = 1,. right = 2;

序列和小于 S 时，移动right，大于 S 时，移动 left，直到rght 为 （S + 1）/ 2;

import java.util.ArrayList;
public class Solution {
    public ArrayList<ArrayList<Integer> > FindContinuousSequence(int sum) {
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if(sum < 3){
            return result;
        }
        int start = 1;
        int end = 2;

        while(start < end && end <= (sum + 1) / 2){
            int curSum = 0;
            for(int i = start; i <= end; i++) {
                curSum += i;
            }
            if(curSum == sum){
                ArrayList<Integer> curResult = new ArrayList<>();
                for(int i = start; i <=end; i++){
                    curResult.add(i);
                }
                result.add(curResult);
                end++;
            }else if(curSum > sum){
                start++;
            }else{
                end++;
            }
        }
        return result;
    }
}
58.1 翻转单词顺序列

【题目】

例如，“student. a am I”。后来才意识到，这家伙原来把句子单词的顺序翻转了，正确的句子应该是“I am a student.”。Cat对一一的翻转这些单词顺序可不在行，你能帮助他么？

隐含要求：只能使用字符数组

【思路】

//字符串方法：不推荐
public class Solution {
    public String ReverseSentence(String str) {
        if(str == null || str.length() == 0 || str.length() == 1 || str.trim().equals("")){
            return str; // 【错误处】：字符串的比较不能用 ==
        }
        String[] strArr = str.split(" ");
        reverse(strArr, 0, strArr.length - 1);
        StringBuilder result = new StringBuilder();
        for(int i = 0; i < strArr.length - 1; i++){
            result.append(strArr[i]).append(" ");
        }
        result.append(strArr[strArr.length - 1]);
        return result.toString();
    }
    
    private void reverse(String[] strArr, int start, int end){
        while(start < end){
            String tmp = strArr[start];
            strArr[start] = strArr[end];
            strArr[end] = tmp;
            start++;
            end--;
        }
    }
}
//推荐
public class Solution {
    public String ReverseSentence(String str) {
        char[] charArr = str.toCharArray();
        int start = 0, end = 0;
        while(end <= str.length()){
            if(end == str.length() || charArr[end] == ' '){  //【错误处】：反转时不该包括 “ ”
                reverse(charArr, start, end - 1);  
                start = end + 1;
            }
            end++;
        }
        reverse(charArr, 0, str.length() - 1);
        return new String(charArr);
    }
    private void reverse(char[] charArr, int start, int end){
        while(start < end){
            swap(charArr, start++, end--);
        }
    }
    
    private void swap(char[] arr, int i, int j){
        char t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}
58.2 左旋转字符串

【题目】

汇编语言中有一种移位指令叫做循环左移（ROL），现在有个简单的任务，就是用字符串模拟这个指令的运算结果。对于一个给定的字符序列S，请你把其循环左移K位后的序列输出。例如，字符序列S=”abcXYZdef”,要求输出循环左移3位后的结果，即“XYZdefabc”。是不是很简单？OK，搞定它！

【思路】

与上题思路类似，内循环 + 外循环

public class Solution {
    public String LeftRotateString(String str,int k) {
        if(str == null || str.trim().equals("")){ //【错误处】未判空
            return str;
        }
        char[] chars = str.toCharArray();
        int len = chars.length;
        reverse(chars, 0, k - 1);
        reverse(chars, k, len - 1);
        reverse(chars, 0, len - 1);
        return new String(chars);
    }
    
    private void reverse(char[] arr, int start, int end){
        while(start < end){
            swap(arr, start++, end--);
        }
    }
    
    private void swap(char[] arr, int i, int j){
        char t = arr[i];
        arr[i] = arr[j];
        arr[j] = t;
    }
}
59. 滑动窗口的最大值

【题目】

给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。

例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个：

{[2,3,4],2,6,2,5,1}，

{2,[3,4,2],6,2,5,1}，

{2,3,[4,2,6],2,5,1}，

{2,3,4,[2,6,2],5,1}，

{2,3,4,2,[6,2,5],1}，

{2,3,4,2,6,[2,5,1]}。

【思路】

维持一个双端队列（具有getMax功能的队列）

令队列首始终为队列最大值，新入队的必须保证为当自己为队首时是最大值，如果前面有比自己小的，就全部去掉（保存的是下标）

import java.util.*;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size)
    {
        ArrayList<Integer> result = new ArrayList<>();
        if(num == null || num.length == 0 || size < 1 || num.length < size){
            return result;
        }
        Deque<Integer> deque = new LinkedList<>();
        for(int i = 0; i < num.length; i++){
            while(!deque.isEmpty() && num[deque.peekLast()] < num[i]){
                deque.pollLast();
            }
            deque.offerLast(i); //存储的是下标
            if(deque.peekFirst() <= i - size){
                deque.pollFirst();
            }
            if(i >= size - 1){
                result.add(num[deque.peekFirst()]);
            }
        }
        return result;
    }
}
60. n 个骰子的点数

【题目】

把 n 个骰子扔在地上，求点数和为 s 的概率。

【思路】

动态规划

i

f(i, j) = f(i - 1, j - 1) + f(i - 1, j - 2) + f(i - 1, j - 3) + f(i - 1, j -4) + f(i - 1, j - 5) + f(i - 1, j - 6)

//二维数组 空间复杂度 O(N^2)
public List<Map.Entry<Integer, Double>> dicesSum(int n){
    final int maxNum = 6 * n;
    final double totalNum = Math.pow(6, n);
    long[][] dp = new long[n + 1][maxNum + 1];
    
    for(int i = 1; i <= 6; i++){
        dp[1][i] = 1;
    }
    for(int i = 2; i <= 6; i++){
        for(int j = i; j <= maxNum; j++){
            for(int k = 1; k <= 6 && k <= j; k++){
                dp[i][j] += dp[i - 1][j - k];
            }
        }
    }
    
    List<Map.Entry<Integer, Double>> ret = new ArrayList<>();
    for(int i = n; i <= maxNum; i++){
        ret.add(new AbstractMap.SimpleEntry(i, dp[i][n]) / totalNum);
    }
    return ret;
}
//旋转数组 空间 O(N)
public List<Map.Entry<Integer, Double>> DicesSum(int n){
    int maxNum = 6 * n;
    int totalNum = Math.pow(6, n);
    long[][] dp = long[2][maxNum + 1];
    
    for(int j = 1; i <= 6; j++){
        dp[0][i] = 1;
    }
    int flag = 1;
    for(int i = 2; i <= n; i++, flag = 1 - flag){
        for(int j = 0; j <= maxNum; j++){
            dp[flag][j] = 0;  //旋转数组清零
        }
        
        for(int j = i; j <= maxNum; j++){
            for(int k = 1; k <= 6 && k <= j; k++){
                dp[flag][j] += dp[1 - flag][j - k];
            }
        }
    }
}
61. 扑克牌顺子

【题目】

LL今天心情特别好,因为他去买了一副扑克牌,发现里面居然有2个大王,2个小王(一副牌原本是54张_)…他随机从中抽出了5张牌,想测测自己的手气,看看能不能抽到顺子,如果抽到的话,他决定去买体育彩票,嘿嘿！！“红心A,黑桃3,小王,大王,方片5”,“Oh My God!”不是顺子…LL不高兴了,他想了想,决定大\小 王可以看成任何数字,并且A看作1,J为11,Q为12,K为13。上面的5张牌就可以变成“1,2,3,4,5”(大小王分别看作2和4),“So Lucky!”。LL决定去买体育彩票啦。 现在,要求你使用这幅牌模拟上面的过程,然后告诉我们LL的运气如何， 如果牌能组成顺子就输出true，否则就输出false。为了方便起见,你可以认为大小王是0。

【思路】

  1. 对数组排序
  2. 找出前面 0 的个数
  3. 遍历后面非零数，计算相邻待补全数
  4. 与 0 的个数比较
import java.util.*;
public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers == null || numbers.length < 5){
            return false;
        }
        Arrays.sort(numbers);
        int zeroNum = 0;
        for(int number : numbers){ // 统计癞子数量
            if (number == 0){
                zeroNum++;
            }
        }
        for(int i = zeroNum; i < numbers.length - 1; i++){
            if (numbers[i] == numbers[i + 1]){
                return false;
            }
            zeroNum -= numbers[i + 1] - numbers[i] - 1; //使用癞子补全
        }
        return zeroNum >= 0 ;
    }
}
62. 圆圈中最后剩下的数 （约瑟夫环）

【题目】

每年六一儿童节,牛客都会准备一些小礼物去看望孤儿院的小朋友,今年亦是如此。HF作为牛客的资深元老,自然也准备了一些小游戏。其中,有个游戏是这样的:首先,让小朋友们围成一个大圈。然后,他随机指定一个数m,让编号为0的小朋友开始报数。每次喊到m-1的那个小朋友要出列唱首歌,然后可以在礼品箱中任意的挑选礼物,并且不再回到圈中,从他的下一个小朋友开始,继续0…m-1报数…这样下去…直到剩下最后一个小朋友,可以不用表演,并且拿到牛客名贵的“名侦探柯南”典藏版(名额有限哦!!_)。请你试着想下,哪个小朋友会得到这份礼品呢？(注：小朋友的编号是从0到n-1)

如果没有小朋友，请返回-1

【思路】

方法1：循环数组模拟 O(MN)

方法2：数学归纳法

//循环数组模拟
public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        if(n < 1 || m < 0){
            return -1;
        }
        int[] arr = new int[n];
        int i = -1, step = 0, count = n;
        while(count > 0){
            i++;
            if(i >= n) i = 0;   //循环
            if(arr[i] == -1) continue; 
            step++;
            if(step == m){
                step = 0;
                arr[i] = -1; //设置为已经移除
                count--;
            }
        }
        return i;
    }
}
//数学归纳
public class Solution {
    public int LastRemaining_Solution(int n, int m) {
        if(n < 1 || m < 0){
            return -1;
        }
        int last = 0;
        for(int i = 2; i <= n; i++){
            last = (last + m) % i;
        }
        return last;
    }
}
63. 股票的最大利润

【题目】

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

如果你最多只允许完成一笔交易（即买入和卖出一支股票一次），设计一个算法来计算你所能获取的最大利润。

注意：你不能在买入股票前卖出股票。

【思路】

假设 diff[i] 表示 以 i 位置为买出价时的最大利润，用 min 表示 i 之前的最小值

class Solution {
    public int maxProfit(int[] prices) {
        if(prices == null || prices.length < 2){
            return 0;
        }
        int min = prices[0];
        int max = prices[1] - min;
        for(int i = 2; i< prices.length; i++){
            if(prices[i - 1] < min) {
                min = prices[i - 1];
            }
            if(prices[i] - min > max){
                max = prices[i] - min;
            }
        }
        return max;
    }
}
64. 求 1+2+3+…+n

【题目】

求1+2+3+…+n，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

【思路】

递归需要条件语句结束循环，可以使用 && 的短路性质

public class Solution {
    public int Sum_Solution(int n) {
        int sum = n;
        boolean b = (n > 0) && ((sum += Sum_Solution(n - 1)) > 0);
        return sum;
    }
}
65. 不用加减乘除做加法

【题目】

写一个函数，求两个整数之和，要求在函数体内不得使用+、-、*、/四则运算符号。

【思路】

异或运算 可以得到未进位时的结果值；

与运算左移一位 是进位值；

a ^ b 表示没有考虑进位的情况下两数的和，(a & b) << 1 就是进位。递归会终止的原因是 (a & b) << 1 最右边会多一个 0，那么继续递归，进位最右边的 0 会慢慢增多，最后进位会变为 0，递归终止。

public class Solution {
    public int Add(int num1,int num2) {
        int n1, n2;
        do{
            n1 = num1 ^ num2; // 不需要进位的结果
            n2 = (num1 & num2) << 1;  //需要进位的位置
            num1 = n1;
            num2 = n2;
        }while(n2 != 0); 
        return n1;
    }
}
66. 构建乘积数组

【题目】

给定一个数组A[0,1,…,n-1],请构建一个数组B[0,1,…,n-1],其中B中的元素B[i]=A[0]A[1]…*A[i-1]A[i+1]…*A[n-1]。不能使用除法。（注意：规定B[0] = A[1] * A[2] * … * A[n-1]，B[n-1] = A[0] * A[1] * … * A[n-2];）

【思路】

将B[i] 的 乘积分成两段 A[0] ~ A[i - 1] 和 A[i + 1] ~ A[n - 1]

import java.util.ArrayList;
public class Solution {
    public int[] multiply(int[] A) {
        int n = A.length;
        int[] B = new int[n];
        for(int i = 0, base = 1; i < n; base *= A[i], i++){
            B[i] = base;
        }
        for(int i = n - 1, base = 1; i >= 0; base *= A[i], i--){
            B[i] *= base;
        }
        return B;
    }
}
67. 把字符串转换成整数

【题目】

将一个字符串转换成一个整数，要求不能使用字符串转换整数的库函数。 数值为0或者字符串不是一个合法的数值则返回0

【思路】

重点是判断各种非法情况

str是否为空；判断正负，并依次决定非法边界；判断除了正负号后每个字符是不是数字

public class Solution {
    public int StrToInt(String str) {
        //最优解
        if(str == null || "".equals(str.trim())){
            return 0;
        }
        char[] arr = str.trim().toCharArray();
        int flag = 1;
        int i = 0;
        int res = 0;
        if(arr[i] == '-'){
            flag = -1;
        }
        if(arr[i] == '-' || arr[i] == '+'){
            i++;
        }
        while(i < arr.length){
            if(isNum(arr[i])){
                int cur = arr[i] - '0'; //【错误处】未减去‘0’
                if(flag == -1 && (res > Integer.MAX_VALUE/10 || res == Integer.MAX_VALUE && cur > 8)){
                    return 0;
                }
                if(flag == 1 && (res > Integer.MAX_VALUE/10 || res == Integer.MAX_VALUE && cur > 7)){
                    return 0;
                }
                res = res * 10 + cur;
                i++;
            }else{
                return 0;
            }
        }
        return res * flag;
    }
    
    public boolean isNum(char c){
        return c >= '0' && c <= '9';
    }
}
68. 树中两个节点的最低公共祖先

【题目】

【思路】
剑指Offer（第二版）面试题53：在排序数组中查找数字出现的次数
冷血之心的博客
07-01 3244
（尊重劳动成果，转载请注明出处：http://blog.csdn.net/qq_25827845/article/details/74065254冷血之心的博客） 剑指Offer（第二版）面试题53：在排序数组中查找数字出现的次数 题目一：数字在排序数组中出现的次数 统计一个数字在排序数组中出现的次数。例如，输入排序数组{1,2,3,3,3,3,4,5}和数字3，由于3在这个数组中出现了4次...
剑指Offer刷题全集 --V1 版本
秦怀杂货店
12-12 1484
文章目录前言1.二维数组中的查找题目描述思路 & 解答暴力破解比较查找法2.替换空格题目描述思路 & 解答调用API函数自实现c++实现3.从尾到头打印链表题目描述思路 & 解答借助栈实现递归调用头插法4.重建二叉树题目描述思路 & 解答5.旋转数组的最小数字题目描述思路 & 解答直接遍历二分法6.斐波那契数列题目描述思路 & 解答直接暴力重复利用结果(动态规划)7.跳台阶题目描述思路 & 解答暴力递归动态规划8.两个栈实现一个队列题目描述思路 &am
LeetCode:53 - II 0 ~ n - 1 中缺失的数字
qq_45239139的博客
02-11 225
题目： 一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。 示例 1: 输入: [3,0,1] 输出: 2 示例 2: 输入: [9,6,4,2,3,5,7,0,1] 输出: 8 源码： class Solution { public int missingNumb...
剑指offer 53
Ding_xiaofei的博客
07-26 365
题目描述 统计一个数字在排序数组中出现的次数。 题解 使用二分搜索 public class Solution { public int GetNumberOfK(int [] array , int k) { return BinSearch(array,k+0.5)-BinSearch(array,k-0.5); } ...
剑指offer-53
ljm911的博客
01-02 242
53.1数字x在排序数组中出现的次数 解法一：遍历数组到X，开始计数，O(N) 解法二：递归使用二分法遍历计数，直至当前分段上下节点出现目标数字K时开始计数 解法三：二分法先查找数字k，再从k开始，往上往下计数 O(logn) 解法四：找出最左一个k和最右一个K，计数 O(logn) 解法三： int GetNumberOfK_Kth(const int* data, int leng...
剑指offer - 面试题53：正则表达式匹配
PeersLee的博客
03-06 902
package Chapter8; /* * '.', 任意字符 * '*', 任意次数 */ public class _53_regular_expressions_matching { public static void main(String[] args) { // char []pattern = {'a', '.', 'a'}; // char []pattern = ...
剑指offer刷题笔记
11-08
### 剑指Offer刷题笔记知识点解析 #### 一、二维数组查找 **题目描述：** 给定一个二维数组，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。编写一个函数来判断一个给定的数是否存在...
剑指offer刷题日记-链表
01-20
链表03-从尾到头打印链表（python） #采用insert方法 class Solution: def printlist(self,listNode): if not listNode: return [] result=[] while listNode: result.insert(0,listNode.val) ...
剑指offer刷题集锦&数据结构算法学习.zip
12-28
剑指offer刷题集锦&数据结构算法学习 剑指offer刷题集锦&数据结构算法学习 剑指offer刷题集锦&数据结构算法学习 剑指offer刷题集锦&数据结构算法学习 剑指offer刷题集锦&数据结构算法学习 剑指...
《剑指offer刷题》.pdf
最新发布
03-26
《剑指offer刷题》.pdf
leetcode-剑指offer-53
lulchen的博客
04-16 234
正则解法 如果nums[0]之后出现target，肯定是形如’，target’这种，因此可以想到正则。 var search = function(nums, target) { var regnum = new RegExp('(\,'+target+')+') var strnum = nums.join() var nowres = regnum.exec(strn...
剑指 Offer（第2版）面试题 53：在排序数组中查找数字
ProgramNovice的博客
12-27 1195
剑指 Offer（第2版）面试题 53：在排序数组中查找数字
剑指offer53(二分的应用)
qq_45892987的博客
11-08 143
接下来的这几个题目是以二分查找算法为基础,考察该算法的灵活应用 题目一: 解析: 在排序的数组中查找数字,我们首先相当的是二分查找.然后要统计target在数组中出现的次数,我们不妨找到第一个target的下标first,然后找到最后一个target的下标last,次数即为last-first+1. 代码: //找目标值第一次出现 int GetFirstK(vector<int> data, int k, int l, int r) //k即为目标 { int mid
剑指offer-53.表示数值的字符串
无关风月
08-23 236
牛客 题目描述 请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串”+100”,”5e2”,”-123”,”3.1416”和”-1E-16”都表示数值。 但是”12e”,”1a3.14”,”1.2.3”,”+-5”和”12e+4.3”都不是。 题解： 方法一： 遍历整个字符串，按照规则检查。 class Solution2 { public boolean...
【todo+低频】【难点】剑指offer——面试题53：正则表达式匹配
Allenlzcoder的博客
03-29 461
剑指offer——面试题53：正则表达式匹配 这个属于不是那么好做的题目之一。。。参考网址：https://www.nowcoder.com/profile/3639006/codeBookDetail?submissionId=19276572 代码中的注释写的不是太清楚，加一点： 一、当模式中的第二个字符不是“*”时： 1、如果字符串第一个字符和模式中的第一个字符相匹配...
剑指 Offer 53 - I. 在排序数组中查找数字 I
JehanRio's Private Blog
07-18 75
还是要注意细节，边界问题很容易出错。
剑指Offer 53题 正则表达式匹配 Java版
yuhushangwei的专栏
10-04 595
package test; public class Match { public boolean match(String str, String pattern){ if(str == null || pattern==null) return false; return matchCore(str, pattern); } public boolean mat
剑指Offer 53 正则表达式
墨
04-10 233
题目描述请实现一个函数用来匹配包括’.’和’‘的正则表达式。模式中的字符’.’表示任意一个字符，而’‘表示它前面的字符可以出现任意次（包含0次）。 在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串”aaa”与模式”a.a”和”ab*ac*a”匹配，但是与”aa.a”和”ab*a”均不匹配思路 其实难点有两个，一个就是*的处理，因为包含三种情况；还有就是指针控制 代码 static pu
剑指 Offer 53 - II： 0～n-1中缺失的数字
MengyuyangEddy的博客
06-16 215
看到这道题的第一反应就是二分查找，由于是递增的所以二分查找所需的时间很短 ，设置一个左，一个右，一个中间，如果判断吧不同需要想下前面是否一样，如果是那么就找到，不是再继续二分查找。没有最后一个多余的判断的话，会永远返回0，因为程序是有可能跳出循环的，就是在当前长度找不到的时候，所以直接返回length即可（只有这一种可能找不到从而跳出循环）谨记，一定是和nums的长度比较，因为找不到的话，那么就说明最后L和R会收敛至相等的程度，然后L+1（越界，等于length），所以才需要和length去比较！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值