剑指offer系列刷题

已于 2022-06-20 10:02:16 修改
阅读量1.5k 收藏
点赞数
分类专栏： 刷题 文章标签： leetcode 算法 职场和发展
于 2022-06-15 09:43:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43147335/article/details/125290897
版权

剑指offer！


秋招对我好点！

JZ 12. 矩阵中的路径

题目链接

***分析：*** 使用回溯和递归 只要找到一个结果就可以返回
哎，还是对递归不太熟悉，他认识我，我不认识他！
继续学习吧！冲！
class Solution {
public:

    bool dfs(vector<vector<char>>& board, string word,vector<vector<bool>>& visited,int m,int n,int i,int j,int k){

        // 递归结束
        if(i<0 || i>=m || j<0 || j>=n || visited[i][j] ==true || board[i][j]!=word[k]) return false;

        if(k==word.size()-1) return true;  // 返回值
 
        visited[i][j] = true;

        bool flag = dfs(board,word,visited,m,n,i-1,j,k+1)||
        dfs(board,word,visited,m,n,i+1,j,k+1)||
        dfs(board,word,visited,m,n,i,j-1,k+1)||
        dfs(board,word,visited,m,n,i,j+1,k+1);
        
        visited[i][j] = false;

        return flag;
    }
    bool exist(vector<vector<char>>& board, string word) {
        int m = board.size();
        int n = board[0].size();

        vector<vector<bool>> visited(m,vector<bool>(n,false));

        for(int i=0;i<m;++i){
            for(int j=0;j<n;++j){
                if (dfs(board,word,visited,m,n,i,j,0)) return true; 
            }
        }
        return false;
    }
};

JZ 13. 机器人的运动范围

题目链接
分析： 由于机器可以向右或者向下运动，并且题目求解的是能够到达的格子数，而不是分析运动到右下角会出现的一些问题，因此我们选择广度优先搜索，而不是深度优先搜索。
广度优先搜索类似于二叉树的层次遍历（每次分析上一个节点能达到的所有情况），选择队列queue进行辅助

深度优先搜索由于是递归问题，所以可以使用栈来辅助，递归问题从本质上来说就是利用栈来实现的，这也是为什么递归可以保留上一次递归的信息（先进后出的栈功不可没！）

class Solution {
public:

    int getNum(int x){
        int res = 0;
        while(x!=0){
            res += x%10;
            x/=10;
        }
        return res;
    }

    int movingCount(int m, int n, int k) {
        // 使用广度优先搜索
        // 使用队列来辅助
        if(k==0) return 1;
        queue<pair<int,int>> q;
        vector<vector<int>> visited(m,vector<int>(n,0));
        int ans = 1;
        q.push(make_pair(0,0));
        visited[0][0] = 1;
        int dx[2] = {0,1};
        int dy[2] = {1,0};

        while(!q.empty()){
            auto [x,y] = q.front();
            q.pop();

            // 广度有限搜索
            for(int i=0;i<2;++i){
                int tx = x  + dx[i];
                int ty = y + dy[i];

                if(tx<0 || tx>=m || ty<0 || ty>=n || visited[tx][ty] || getNum(tx) + getNum(ty)>k) continue;
                q.push(make_pair(tx,ty));
                ans++;
                visited[tx][ty] = 1; 
            }
        }

        return ans;
    }
};

JZ 14- I. 剪绳子

题目链接
分析： 从数学角度来分析，尽量将绳子剪成长度为3，结果的乘积会最大
可能是由于3是第一个质数前的最大素数？

class Solution {
public:
    int cuttingRope(int n) {
    
        if(n==2) return 1;
        if(n==3) return 2;
        if(n==4) return 4;

        int number = 1;
        while(n!=0){
            if(n==4 || n==2){
                number*=n;
                n=0;
                break;
            }
            number*=3;
            n-=3;
        
        }
        return number;
    }
};`

JZ 14- II. 剪绳子 II

题目链接
分析： 跟上面是一样的 ，尽量分成3， 不过由于数值较大， 每步计算都需要对1000000007取余

class Solution {
public:
    int cuttingRope(int n) {
        // 剪绳子  这里的绳子比较长
        // 跟之前还是一样的  尽量分成多的34
        if(n<=3) return n-1;
        int mod = 1000000007;
        int x = n/3;
        int y = n%3;
        long number =1;
         if(y==0){
             for(int i=0;i<x;++i){
                 number*=3;
                 number%=mod;
             }
         }else if(y==1){
             for(int i=1;i<x;++i){
                 number*=3;
                 number%=mod;
             }
             number*=4;
         }else{
             for(int i=0;i<x;++i){
                 number*=3;
                 number%=mod;
             }
             number*=2;
         }
         number%=mod;
        return (int)number;
    }
};

JZ 26 树的子结构

题目链接
分析： 对于树的子结构问题，一般都采用递归。
主要步骤有两个：

  1. 在树 A 中找到和树 B 的根节点的值一样的节点 p
  2. 判断树 A 中以 p 为根节点的子树是不是包含和树 B 一样的结构
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSub(TreeNode* root1, TreeNode* root2){

        if(!root2) return true;
        if(!root1 || root1->val != root2->val) return false;
        return isSub(root1->left,root2->left) && isSub(root1->right,root2->right);
    }
    
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        // 使用递归
        if(!A || !B) return false;   // 如果A B为nullptr的话 返回false

        return isSub(A,B) || isSubStructure(A->left,B) || isSubStructure(A->right,B);
    }
};

JZ 27 二叉树的镜像

题目链接
分析： 将root的两个子树先保存下来，一直递归到最深处，进行交换。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {

        if(!root) return NULL;

        TreeNode* left = mirrorTree(root->left);
        TreeNode* right = mirrorTree(root->right);

        root->right = left;
        root->left  =right;

        return root;
    }
};

JZ 28 对称的二叉树

题目链接
分析： 如果一棵二叉树和它的镜像一样，那么它是对称的。
因此判断条件可视为 两个树在什么情况下是镜像对称的：

  1. 它们的两个根结点具有相同的值
  2. 每个树的右子树都与另一个树的左子树镜像对称
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:

    bool check(TreeNode* root1,TreeNode*root2){
        if(!root1 && !root2) return true;
        if(!root1 || !root2) return false;

        return root1->val==root2->val && check(root1->right,root2->left) && check(root2->right,root1->left);
    }
    bool isSymmetric(TreeNode* root) {
        // 根节点有相同的值  并且一个树的左子树和另一棵树的右子树镜像对称
        return check(root,root);
    }
};

JZ 34 二叉树中和为某一值的路径

题目链接
分析： 想都不要想，这题肯定采用深度优先搜索的方式，枚举每一条从根节点到叶子节点的路径。当我们遍历到叶子节点，且此时路径和恰为目标和时，我们就找到了一条满足条件的路径。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
private:
    vector<vector<int>> result;
    vector<int> path;

public:
    void dfs(TreeNode* root,int target,int num){
        // 递归结束
        if(!root) return;

        path.push_back(root->val);
        num+=root->val;

        if(!root->left && !root->right && num==target){
            result.push_back(path);
        }

        dfs(root->left, target,num);
        dfs(root->right, target,num);
        path.pop_back();

    }
    vector<vector<int>> pathSum(TreeNode* root, int target) {
        // 使用递归  深度优先搜索
        dfs(root,target,0);
        return result;
    }
};

JZ 66 构建乘积数组

题目链接
分析：
可以直接暴力求解，时间复杂度是O(N^2)
但是也可以像动态规划那里，利用上一步的计算结果直接得到当前的结果
所以将乘积分成左右两个部分计算，左边的乘积从左到右计算，右边的乘积从右到左计算，最后再合并到一起！

class Solution {
public:
    vector<int> constructArr(vector<int>& a) {
        // 分成两部分来计算
        int length = a.size();
        if(length==0) return vector<int>{};  // 空输入
        vector<int> res(length,0);
        vector<int> left(length,0);
        vector<int> right(length,0);

        // 计算i左边的乘积
        left[0] = 1;
        for(int i=1;i<length;++i){
            left[i] = left[i-1] * a[i-1];
        }

        // 计算i右边的乘积
        right[length-1] =1;
        for(int i=length-2;i>=0;--i){
            right[i] = right[i+1] * a[i+1];
        }

        // 合并
        for(int i=0;i<length;++i){
            res[i] = left[i] * right[i];
        }

        return res;
    }
};

JZ 67 把字符串转换成整数

题目链接
分析：
耐心去分析，把所有情况都分析到位了！

class Solution {
public:
    int strToInt(string str) {
        // 练习一下自己的逻辑能力
        long long number = 0;
        int size = str.size();

        // 去除空格
        int i=0;
        while(i<size && str[i]==' ') i++;
        cout<<"i:"<<i<<endl;
        cout<<str[3]<<endl;
        bool flag = true;  
        // 空格
        if(i==size) return 0;
        // 第一个数值是其他字母的
        else if(str[i]!='+' && str[i]!='-' && (str[i]>'9' || str[i]<'0')) return 0;
        else{
            if(str[i]=='+'){
                i++;
            }else if(str[i]=='-'){
                i++;
                flag = false;
            }
            while(i<size && str[i]<='9' && str[i]>='0'){
                number *=10;
                number+=str[i]-'0';
                if(number>INT_MAX) break;
                i++;
        }
        }
        if(!flag) number*=-1;
        // else if(str[i]=='+'){
        //     i++;
        //     while(i<size && str[i]<='9' && str[i]>='0'){
        //         number *=10;
        //         number+=str[i]-'0';
        //         if(number>INT_MAX) break;
        //         i++;
        //     }
        // }
        // else if(str[i]=='-'){
        //     cout<<"1"<<endl;
        //     i++;
        //     while(i<size && str[i]<='9' && str[i]>='0'){
        //         number *=10;
        //         number+=str[i]-'0';
        //         if(number>INT_MAX) break;
        //         i++;
        //     }
        //     number*=-1;
        //     cout<<number<<endl;
        // }else{
        //     while(i<size && str[i]<='9' && str[i]>='0'){
        //         number *=10;
        //         number+=str[i]-'0';
        //         if(number>INT_MAX) break;
        //         i++;
        //     }
        // }
        if(number>=INT_MAX) return INT_MAX;
        if(number<=INT_MIN) return INT_MIN;
        return (int)number;
    }
};

JZ 68 - I. 二叉搜索树的最近公共祖先

题目链接
分析：
可以用二分查找，也可以使用递归求解！

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 二叉树是一样的
        // 使用递归 
        // 返回值是最近公共祖先
        if(root==nullptr) return nullptr;
        if(root==p || root ==q) return root;

        TreeNode* left = lowestCommonAncestor(root->left,p,q);
        TreeNode* right = lowestCommonAncestor(root->right,p,q);

        if(left==nullptr && right==nullptr) return nullptr;
        if(left==nullptr) return right;
        if(right==nullptr) return left;

        return root;
        
    }
};

JZ 68 II. 二叉树的最近公共祖先

题目链接
分析：
最近工作祖先存在三种情况：

  1. 左子树和右子树都存在一个
  2. 只存在与左子树中
  3. 只存在右子树中

先搜索到最深处，再递归回来，进行判断。
**需要时刻记住的是：**递归的返回值是什么！

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        // 使用dfs

        if(root==nullptr || root == p || root == q) return root;    // 递归结束
        
        // 递归需要时刻记住的是 返回的是什么 
        TreeNode* left = lowestCommonAncestor(root->left,p,q); 
        TreeNode* right = lowestCommonAncestor(root->right,p,q);  

        if(left!=nullptr && right!=nullptr) return root;  // 左子树和右子树都不为空
        if(left==nullptr) return right; // 左子树为空 全在右子树
        if(right==nullptr) return left; // 右子树为空  全在左子树

        return nullptr; 
        
    }
};
20要继续努力哦!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指Offer2刷题
weixin_43868436的博客
09-21 139
剑指Offer第二版刷题记录
剑指offer-Java刷题心得
xyzhang的博客
10-10 340
剑指offer 一. Java查找二维数组时，如何确定二维数组的行列长度 确定二维数组行数：int rowLength = array.length; 确定二维数组列数：int colLength = array[0].length; 二。 请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy...
剑指offer系列刷题笔记汇总
好想去看海
09-06 206
剑指Offer系列刷题笔记汇总 flyingsen 2018-06-04 09:37:29 352 收藏 分类专栏： 剑指offer 本文转自：个人网站：点击查看 一前言 二总结 链表-8道 二叉树12道 二叉搜索树3道 数组11道 字符串8道 栈3道 递归4道 回溯法2道 其他15道 一、前言 本系列文章为《剑指Offer》刷题笔记。 刷题平台：牛客网 书籍下载：共享资源 刷题刷的比较慢，花费了两个多月，终于将所有题目过了一遍，牛客
剑指Offer系列刷题笔记汇总
Candy_GL的博客
02-28 272
版权声明：本文为博主原创文章，未经博主允许不得转载。个人网站：http://cuijiahua.com。 https://blog.csdn.net/c406495762/article/details/79247243 本文转自：个人网站：点击查看 一前言 二总结 链表-8道 二叉树12道 二叉搜索树3道 数组11道 字符串8道 栈3道 递归4道 回溯法2道 其他15道 一、前言 本系列文章...
《剑指Offer》刷题笔记汇总
ZY-JIMMY
01-25 1464
文章目录前言源码地址题目分类数组(Array)字符串(String)链表(LinkList)栈和队列(Stack &amp;amp;amp;amp; Queue)数学(Math)回溯法(Backtracking)动态规划(Dynamic Programming) 前言 2018年10月购买的《剑指Offer(第二版)》,平常课业较为繁重，寒假是个刷题的好时间，自己前前后后用了一周的时间刷完了剑指上除了与&amp;amp;quot;树&amp;amp;quot;相关的题目，...
剑指Offer系列刷题笔记
qq_53183211的博客
10-27 238
剑指Offer系列刷题笔记汇总 文章目录剑指Offer系列刷题笔记汇总前言一、目录如下（持续更新） 前言 本系列为《剑指Offer》第二版全集 使用语言：Java 记录自己学习过程 从第一题开始 开始时间2021年10月27日21：00； 一、目录如下（持续更新） ...
剑指offer 分类刷题记录
秀秀的奇妙旅行
03-06 968
树 剑指 Offer 68 - II. 二叉树的最近公共祖先 BST中两节点的最近公共祖先 67 子树最大深度55 最小深度111 平衡二叉树55 另一个树的子树 572 树的子结构 26 镜像二叉树 子树和子结构，都是写一个函数 判断子树和root节点 二叉树的锯齿形层次遍历（按之字顺序打印二叉树） 103 二叉树的层序遍历（把二叉树打印成多行 二维数组输出） 102 需要具体到每层，size for循环 两个容器即可 二叉树的层次遍历 II（从底向上依次按行输出各层节点）107 ..
剑指offer刷题汇总
守得云开见月明
06-02 5461
前言      从今天开始在牛客刷剑指offer，希望每天打卡几个算法，提高自己的编程水平。在CSDN做一下记录，随时更新，一起学习吧。 目录大全 数组 剑指offer ( 一 )：二维数组中的查找 剑指offer ( 六 )：旋转数组的最小数字 剑指offer ( 十三 )：调整数组顺序使奇数位于偶数前面【代码完整性】 剑指offer（二十八）：数组中出现次数超过一半的数字【 时间效率】...
【剑指offer系列刷题】第一篇——寻找单身狗
weixin_58450087的博客
10-11 513
❤️《剑指offer》系列刷题——第一篇 ❤️ 题目来源：数组中数字出现的次数（大家可以去测试一下自己的代码） ❤️ 博主码云gitee链接：https://gitee.com/byte-binxin ❤️ 文章目录前言题目描述解题思路解题代码 前言 这是《剑指offer》系列刷题第一篇文章，大家可以互相学习一下。 题目描述 题目描述 一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。 事例1： .
《剑指offer》刷题记录汇总篇
郑德帅
06-24 566
《剑指offer》刷题汇总1 前言2 刷题网站3 刷题笔记汇总 1 前言   最近啃了个把月的数据结构与算法，有点飘了，准备拿牛客网的剑指offer模块练练手，个人觉得自己刚入门(或许还没入)，所以这篇博客比较适合想学习数据结构或者刚接触数据机构的新手朋友朋友们，当然，大佬们也可以看看，一是指导，二是差缺补漏。   刷题顺序即题目顺序，时间的话大概一周 2 刷题网站 点击直达:剑指offer 3 刷题笔记汇总 题号 题目 知识点 JZ1 二维数组中的查找 数组、查找 JZ2 替换空格 字
剑指offer刷题
12-20
【剑指offer刷题】系列主要针对编程面试中常见的算法问题进行解析，旨在提升编程者在面试中的竞争力。本文将详细讲解其中的四个经典题目，包括二维数组中查找、替换空格、从尾到头打印链表以及重建二叉树。 1. **二...
剑指offer刷题记录——树
01-20
把二叉树打印成多行 题目描述 从上到下按层打印二叉树，同一层结点从左至右输出。每一层输出一行。 实现思路 BFS即可，树的题目切记刚开始要判断顶点是否为空。 具体实现 /* struct TreeNode { ...
剑指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》刷题笔记——面试题05. 替换空格
12-22
1、剑指解析： 2、特殊用例： 3、代码实现： I、原地双指针（从后向前复制）   从后向前复制是《剑指》推荐的一种解法，可以适用于各种编程语言。每' '比' '多两个字符。两个指针都是从后向前。通过先统计字符串...
力扣 102题 二叉树的层次遍历 记录
m0_49800270的博客
07-22 654
队列是一种先进先出（FIFO）的数据结构，非常适合于层序遍历，因为我们总是希望按照从树的上层到下层的顺序处理节点。队列操作：使用一个队列来管理待处理的树节点。队列的先进先出特性保证了树的每一层都按照从左到右的顺序被处理。
力扣202.快乐数
最新发布
gyj215500的博客
07-25 216
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
【Hot100】LeetCode—152. 乘积最大子数组
weixin_44382896的博客
07-23 278
【代码】【Hot100】LeetCode—152. 乘积最大子数组。
C++ | Leetcode C++题解之第275题H指数II
Ddddddd_158的博客
07-23 354
C++ | Leetcode C++题解之第275题H指数II
"剑指Offer刷题：二维数组中查找问题解析
剑指offer是一本非常经典的面试书籍，其中的编程题目常常被用于各种面试中。而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值