剑指offer专题——day02

最新推荐文章于 2023-12-31 20:15:26 发布
最新推荐文章于 2023-12-31 20:15:26 发布
阅读量174 收藏
点赞数
分类专栏： 刷题第一轮
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lwycc2333/article/details/107849036
版权

（1）剑指 Offer 13. 机器人的运动范围

（2）剑指 Offer 14- I. 剪绳子

（3）剑指 Offer 14- II. 剪绳子 II

（4）剑指 Offer 15. 二进制中1的个数

（5）剑指 Offer 16. 数值的整数次方

（6）剑指 Offer 18. 删除链表的节点

（7）剑指 Offer 19. 正则表达式匹配

（8）剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

（9）剑指 Offer 22. 链表中倒数第k个节点

（10） 剑指 Offer 24. 反转链表

--------------------------------------------------------------------------

剑指 Offer 13. 机器人的运动范围

Difficulty: 中等

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

示例 1：

输入：m = 2, n = 3, k = 1
输出：3

示例 2：

输入：m = 3, n = 1, k = 0
输出：1

提示：

  • 1 <= n,m <= 100
  • 0 <= k <= 20
Solution：关键点：机器人要一步一步的走，被挡住的地方即使数位和小于k也是过不去的
​
//关键点：机器人要一步一步的走
//被挡住的地方即使数位和小于k也是过不去的

class Solution {
    public int movingCount(int m, int n, int k) {
        boolean[][] used = new boolean[m][n];
        return getCount(m, n, 0, 0, k, used);
    }

    public int getCount(int m, int n, int i, int j, int k, boolean[][] used){
        int count = 0;
        if(i<0 || i>=m || j<0 || j>=n || used[i][j] || getSum(i)+getSum(j)>k){
            return 0;
        }
        count++;
        used[i][j] = true;
        
        count += getCount(m, n, i-1, j, k, used);   //四个方向
        count += getCount(m, n, i, j-1, k, used);
        count += getCount(m, n, i+1, j, k, used);
        count += getCount(m, n, i, j+1, k, used);
        return count;
    }

    public int getSum(int i){
        int sum = 0;
        while(i != 0){
            sum += i%10;
            i = i/10;
        }
        return sum;
    }
}

剑指 Offer 14- I. 剪绳子

Difficulty: 中等

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m-1] 。请问 k[0]*k[1]*...*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

提示：

  • 2 <= n <= 58

注意：本题与主站 343 题相同：

Solution：解法1：暴力；解法2：找规律
​// 方法一：暴力解法
//class Solution {
//     public int cuttingRope(int n) {
//         int max = 0;
//         for(int i=2; i<=n; i++){   //分成几段
//             int x = n/i, y = n%i;
//             int sum = 1;
//             for(int j=0; j<i; j++){
//                 if(y > 0){
//                     sum *= (x+1);
//                     y--;
//                 }
//                 else sum *= x;
//             }
//             max = Math.max(max, sum);
//         }
//         return max;
//     }
// }

//方法二：规律：当n大于3的时候，优先选3；
//当n=1的时候，挪出一个3 ，凑成4；
//当n=2的时候，直接乘以2

class Solution{
    public int cuttingRope(int n) {
        if(n == 2) return 1;
        if(n == 3) return 2;  //m>1，所以只能分成2和1
        if(n == 4) return 4;

        int sum = 1;
        while(n > 4){
            sum *= 3;
            n -= 3;
        }
        return sum*n;
    }
}

剑指 Offer 14- II. 剪绳子 II

Difficulty: 中等

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]...k[m - 1] 。请问 k[0]*k[1]*...*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1

示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

提示：

  • 2 <= n <= 1000

注意：本题与主站 343 题相同：

Solution：使用上一题的规律，而且要将sum定义成long
​//关键点：使用上一题的规律，而且要将sum定义成long
class Solution {
    public int cuttingRope(int n) {
        if(n == 2) return 1;
        if(n == 3) return 2;
        if(n == 4) return 4;

        long sum = 1;
        while(n > 4){
            sum = sum*3%1000000007;
            n = n-3;
        }
        return (int)(sum*n%1000000007);
    }
}

剑指 Offer 15. 二进制中1的个数

Difficulty: 简单

请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。

示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。

示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

注意：本题与主站 191 题相同：

Solution：位运算（三个注意的地方）
​public class Solution {
    // you need to treat n as an unsigned value
    public int hammingWeight(int n) {
        int count  = 0;
        while(n != 0){  //（1）不能写n>0，因为负数的二进制也有1
            count = count + (n&1);  // （2）加号的优先级比与运算高,一定要加括号
            n = n>>>1;  //（3）有符号右移>>>，无符号右移>>
        }
        return count;
    }
}

剑指 Offer 16. 数值的整数次方

Difficulty: 中等

实现函数double Power(double base, int exponent)，求base的exponent次方。不得使用库函数，同时不需要考虑大数问题。

示例 1:

输入: 2.00000, 10
输出: 1024.00000

示例 2:

输入: 2.10000, 3
输出: 9.26100

示例 3:

输入: 2.00000, -2
输出: 0.25000
解释: 2-2 = 1/22 = 1/4 = 0.25

说明:

  • -100.0 < x < 100.0
  • n 是 32 位有符号整数，其数值范围是 [−231, 231 − 1] 。

注意：本题与主站 50 题相同：

Solution：快速幂
​/*
    快速幂解法：
        （1）当n为偶数， pow(x, n) = pow(x, n/2) * pow(x, n/2);
        （2）当n为奇数， pow(x, n) = pow(x, n/2) * pow(x, n/2) * x;
    
    初始化条件：
        （1）if(n == 0) return 1;
        （2）if(n == 1) return x;
        （3）if(n == -1) return 1/x;
*/
class Solution {
    public double myPow(double x, int n) {
        if(n == 0) return 1;
        if(n == 1) return x;
        if(n == -1) return 1/x;
        double half = myPow(x, n/2);
        double pow = myPow(x, n%2);
        return half*half*pow;
    }
}

剑指 Offer 18. 删除链表的节点

Difficulty: 简单

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。

返回删除后的链表的头节点。

**注意：**此题对比原题有改动

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

说明：

  • 题目保证链表中节点的值互不相同
  • 若使用 C 或 C++ 语言，你不需要 free 或 delete 被删除的节点
Solution：定义头结点，遍历即可
​/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode deleteNode(ListNode head, int val) {
        ListNode flag = new ListNode(-1), node;
        flag.next = head;
        node = flag;
        while(node!=null && node.next!=null && node.next.val!=val){
            node = node.next;
        }
        node.next = node.next.next;
        return flag.next;
    }
}

剑指 Offer 19. 正则表达式匹配

Difficulty: 困难

请实现一个函数用来匹配包含'. '和'*'的正则表达式。模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但与"aa.a"和"ab*a"均不匹配。

示例 1:

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。

示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。

示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false
  • s 可能为空，且只包含从 a-z 的小写字母。
  • p 可能为空，且只包含从 a-z 的小写字母以及字符 . 和 *，无连续的 '*'。

注意：本题与主站 10 题相同：

Solution：递归，分情况讨论（1.当前元素相等；2.当前元素不相等）
​class Solution {
    public boolean isMatch(String s, String p) {

        char[] str = s.toCharArray();
        char[] ptr = p.toCharArray();
        return help(str, ptr, 0, 0);
    }

    public boolean help(char[] str, char[] ptr, int i, int j){

        int len1 = str.length, len2 = ptr.length;

        if(j == len2) return i==len1;

        if(i == len1){
            if(j == len2-1) return false; //只剩下一个
            if(ptr[j+1] != '*') return false;
            return help(str, ptr, i, j+2);
        }

        if(str[i]==ptr[j] || ptr[j]=='.'){   //相等
            if(j+1<len2 && ptr[j+1]=='*'){
                return help(str, ptr, i, j+2) ||   //匹配0次
                        help(str, ptr, i+1, j+2) ||  //匹配1次
                        help(str, ptr, i+1, j);     //匹配多次
            }
            else{
                return help(str, ptr, i+1, j+1);
            }
        }
        else{  //不相等
            if(j+1<len2 && ptr[j+1]=='*'){  //匹配0次
                return help(str, ptr, i, j+2);
            }
            else return false;
        }
    }
}

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

Difficulty: 简单

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。

示例：

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

提示：

  1. 1 <= nums.length <= 50000
  2. 1 <= nums[i] <= 10000
Solution：双指针法
​class Solution {
    public int[] exchange(int[] nums) {
        int len = nums.length;
        int l = 0, r = len-1;
        while(l < r){
            while(l<r && nums[l]%2 != 0) l++;
            while(l<r && nums[r]%2 == 0) r--;
            if(l < r){
                int temp = nums[l];
                nums[l] = nums[r];
                nums[r] = temp;
            }
        }
        return nums;
    }
}

剑指 Offer 22. 链表中倒数第k个节点

Difficulty: 简单

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有6个节点，从头节点开始，它们的值依次是1、2、3、4、5、6。这个链表的倒数第3个节点是值为4的节点。

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.
Solution：快慢指针
​/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        ListNode slow = head, fast = head;
        for(int i=0; i<k; i++){
            if(fast == null) return null;
            fast = fast.next;
        }

        while(fast != null){
            slow = slow.next;
            fast = fast.next;
        }
        return slow;
    }
}

剑指 Offer 24. 反转链表

Difficulty: 简单

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

限制：

0 <= 节点个数 <= 5000

注意：本题与主站 206 题相同：

Solution：1.递归；2.遍历（类似于头插法）

注意：递归写法，可以模拟一下过程，就知道要怎么写了

​/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null || head.next==null) return head;
        ListNode node = reverseList(head.next);
        head.next.next = head;  //不能写成 node.next = head, 因为node是头结点
        head.next = null;
        return node;
    }
}
lwycc233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
剑指offer刷题记录——树
01-20
把二叉树打印成多行 题目描述 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。 实现思路 BFS即可，树的题目切记刚开始要判断顶点是否为空。 具体实现 /* struct TreeNode { ...
剑指offer专题——day01
lwycc2333的博客
08-06 137
（1）剑指 Offer 03. 数组中重复的数字 （2）287. 寻找重复数 （3）剑指 Offer 04. 二维数组中的查找 （4）剑指 Offer 05. 替换空格 （5）剑指 Offer 06. 从尾到头打印链表 ---------------------------------------------------------------------- 剑指 Offer 03. 数组中重复的数字 Difficulty: 简单 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在
剑指offer题解合集——Week1day2
qq_51931826的博客
12-19 413
剑指offer
剑指offer题解合集——Week2day5
qq_51931826的博客
12-31 691
剑指offer题解合集——Week2day5
剑指offer——day4
qq_53893431的博客
04-10 1214
题目1 int cmp(int*a,int*b) { return *a-*b; } int findRepeatNumber(int* nums, int numsSize){ qsort(nums,numsSize,sizeof(int),cmp); for(int i=1;i<numsSize;i++) { if(nums[i]==nums[i-1]) { return nums[i]; .
剑指offer——day3
qq_53893431的博客
04-09 921
题目1：替换空格 char* replaceSpace(char* s) { int i=0; int j=0; int len = strlen(s); int cnt=0; for (i = 0; i < len; i++) { if (s[i] == ' ') { cnt++; } } char*ans =(char*)malloc(sizeof.
剑指offer——day1
qq_53893431的博客
04-08 239
题目一 题目主要考察的是对栈和队列的理解和基本实现 typedef int STDataType; #define DEFSTACKSIZE 100 typedef struct Stack { STDataType* array; int size; int capacity; }Stack; void CheckCapacity(Stack* ps) { if (ps->size >= ps->capacity) { ps->capacity *= 2
剑指offer——day2
qq_53893431的博客
04-09 174
题目一 思路：两次遍历。一次遍历出链表的元素个数。第二次依次插入数据 int* reversePrint(struct ListNode* head, int* returnSize){ int i=0; struct ListNode*cur=head; while(head) { head=head->next; i++; } *returnSize=i; int*res=(int*)malloc(siz
LeetCode剑指offer——Day1
m0_49003264的博客
09-14 160
LeetCode剑指offer——Day1用两个栈实现队列包含min函数的栈 用两个栈实现队列 用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 示例 1： 输入： [“CQueue”,“appendTail”,“deleteHead”,“deleteHead”] [[],[3],[],[]] 输出：[null,null,3,-1]
剑指offer——牛客网 力扣——day2
weixin_61057398的博客
08-23 203
【代码】剑指offer——牛客网 力扣——day2。
剑指offer 题16——数值的整数次方
01-07
数值的整数次方 题目： 实现函数double Power(double base,int exponent), 求base得exponent次方。不得使用库函数，同时不需要考虑大数问题 因为不需要考虑大数问题，所以看起来似乎很简单，只需要累加就好 ...
剑指offer笔试及源程序
10-31
《剑指offer笔试及源程序》是一份针对IT求职者极具价值的资源，它涵盖了名企面试中常见的编程题目，并提供了详细的源代码解析。这份资料旨在帮助应聘者提升编程技能，增强解决实际问题的能力，从而在面试中脱颖而出...
《剑指Offer》刷题笔记——面试题05. 替换空格
12-22
1、剑指解析： 2、特殊用例： 3、代码实现： I、原地双指针（从后向前复制）   从后向前复制是《剑指》推荐的一种解法，可以适用于各种编程语言。每' '比' '多两个字符。两个指针都是从后向前。通过先统计字符串...
udp分片报文pcap文件
07-18
udp分片报文pcap文件：64kudp大包分成每片658字节总计100片
计算机教学导案.doc
07-18
计算机
摩根：2024年大市前瞻.pdf
最新发布
07-18
摩根：2024年大市前瞻
计算机控制专业技术专题实习任务书温度控制.doc
07-18
计算机
剑指Offer编程题目与Java代码大全
"《剑指Offer》是一本经典的面试宝典，由LeetCode作者郭霖编著，旨在帮助求职者提升编程技能，应对技术面试。该书提供了丰富的编程题目，涵盖多种核心的IT知识点，包括但不限于数据结构、算法、设计模式、性能优化等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值