leetcode 剑指Offer系列 c++

已于 2022-05-09 16:02:21 修改
阅读量439 收藏 1
点赞数 2
分类专栏： leetcode记录 文章标签： leetcode 深度优先 算法 c++
于 2022-05-09 15:52:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/l7_______/article/details/124667916
版权

文章目录

剑指 Offer 04. 二维数组中的查找
class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        if (matrix.size() == 0) return false;
        int n = matrix.size(), m = matrix[0].size();
        int row = 0, column = m - 1;
        while (row < n  && column >= 0) {
            if (matrix[row][column] == target) {
                return true;
            }
            if (matrix[row][column] < target) {
                row++;
            } else {
                column--;
            }
        }
        return false;
    }
};
剑指 Offer 07. 重建二叉树
/**
 * 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:
    unordered_map<int, int> mp;
    TreeNode* BuildNewTree(vector<int>& preorder, vector<int>& inorder, int pre_left, int pre_right, int in_left, int in_right) {
        if (pre_left > pre_right) {
            return NULL; 
        }
        TreeNode* node = new TreeNode(preorder[pre_left]);
        int index = mp[node->val];
        int pre_left_size = index - in_left;
        node->left = BuildNewTree(preorder, inorder, pre_left + 1, pre_left + pre_left_size, in_left, index - 1);
        node->right = BuildNewTree(preorder, inorder, pre_left_size + pre_left + 1, pre_right, index + 1, in_right);
        return node;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int len = preorder.size();
        for (int i = 0; i < len; i++) {
            mp[inorder[i]] = i;
        }
        return BuildNewTree(preorder, inorder, 0, len - 1, 0, len - 1);
    }
};
剑指 Offer 09. 用两个栈实现队列
class CQueue {
public:
    stack<int> stack1;
    stack<int> stack2;
    CQueue() {

    }
    
    void appendTail(int value) {
        stack1.push(value);
    }
    
    int deleteHead() {
        int ret = -1;
        if (stack2.empty()) {
            while (!stack1.empty()) {   
                int temp = stack1.top();
                stack2.push(temp);
                stack1.pop();
            }
        }
        if (stack2.empty()) {
            return ret;
        }
        ret = stack2.top();
        stack2.pop();
        
        return ret;
    }
};

/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */
剑指 Offer 10- I. 斐波那契数列
class Solution {
public:
    int fib(int n) {
        int MOD = 1000000007;
        if (n <= 1) {
            return n;
        }
        // return fib(n - 1) + fib(n - 2);
        int  a = 0, b = 1 , c;
        for (int i = 2; i <= n; i ++) {
            c = (a + b) % 1000000007;
            a = b;
            b = c;
        }
        return c;
    }
};
剑指 Offer 12. 矩阵中的路径
class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        rows = board.size();
        cols = board[0].size();
        for(int i = 0; i < rows; i++) {
            for(int j = 0; j < cols; j++) {
                if(dfs(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }
private:
    int rows, cols;
    bool dfs(vector<vector<char>>& board, string word, int i, int j, int k) {
        if(i >= rows || i < 0 || j >= cols || j < 0 || board[i][j] != word[k]) return false;
        if(k == word.size() - 1) return true;
        board[i][j] = '\0';
        bool res = dfs(board, word, i + 1, j, k + 1) || dfs(board, word, i - 1, j, k + 1) || 
                      dfs(board, word, i, j + 1, k + 1) || dfs(board, word, i , j - 1, k + 1);
        board[i][j] = word[k];
        return res;
    }
};
剑指 Offer 13. 机器人的运动范围
class Solution {
public:
    int ret = 0;
    int countnum (int row, int column) {
        int count = 0;
        while(row) {
            count += row % 10;
            row /= 10;
        }
        while (column) {
            count += column % 10;
            column /= 10;
        }
        return count;
    }
    void dfs(int i, int j, int m, int n, int k, vector<vector<int>> &mp) {
        if (i >= m || j >= n) {
            return;
        }
        if (countnum(i, j) > k || mp[i][j] == -1) {
            mp[i][j] = -1;
            return ;
        }
        
        mp[i][j] = -1;
        ret++;
        
        if (mp[i + 1][j] != -1) {
            dfs(i + 1, j ,m, n, k, mp);
        }
        if (mp[i][j +1] != -1) {
            dfs(i, j + 1, m, n, k, mp);
        }
    }

    int movingCount(int m, int n, int k) {
        //dfs
        vector<vector<int>> mp(m + 1, vector<int>(n + 1, 0));
        dfs(0, 0, m, n, k, mp);
        return ret;
    }
};
剑指 Offer 14- I. 剪绳子
class Solution {
public:
    int cuttingRope(int n) {
        //dp[i] = max(前面保持不动，cur长度取1 ； 长度取j， 前面长度为i-j ； 长度取j， 前面为dp[i - j])
        //为什么i-j 和dp[i-j]不冲突，因为m>1，所以dp[i-j]代表里面剪了，i-j代表没剪
        vector<int> dp(n + 1);
        int cur_max;
        for (int i = 2; i <= n; i++) {
            cur_max = 0;
            for (int j = 1; j <= i; j++) {
                cur_max = max({cur_max,j * (i - j), j * dp[i - j] });
            }
            dp[i] = cur_max;
        }
        return dp[n];
    }
};
剑指 Offer 14- II. 剪绳子 II
class Solution {
public:
    int cuttingRope(int n) {
        if (n <= 3) return n - 1;
        int MOD = 1000000007;
        long ret = 1;
        if (n % 3 == 1) {   //3 * 1 < 4
            ret = 4;
            n = n - 4;
        }
        if (n % 3 == 2) {
            ret = 2;
            n = n - 2;
        }
        while (n) {
            n = n - 3;
            ret = ret * 3 % MOD;
        }
        return ret;
    }
};
剑指 Offer 16. 数值的整数次方
class Solution {
public:
    double myPow(double x, int n) {
        //用二进制想问题 11(3)、2^10
        double ret = 1.0;
        for (int i = n; i != 0; i /= 2) {
            if (i % 2 != 0) {
                ret *= x;
            }
            x *= x;
        }
        return n >= 0 ? ret : 1 / ret;
    }
};
剑指 Offer 20. 表示数值的字符串
class Solution {
public:
    bool isNumber(string s) {
        //正则表达式 确定有限状态自动机(DFA)
        // 空格 +/- 数字 . E/e 
        int tansfer[9][5] = {
            {0, 1, 2, 4, -1},
            {-1, -1, 2, 4, -1},
            {8, -1, 2, 3, 5},
            {8, -1, 3, -1, 5},
            {-1, -1, 3, -1, -1},
            {-1, 6, 7, -1, -1},
            {-1, -1, 7, -1, -1},
            {8, -1, 7, -1, -1},
            {8, -1, -1, -1, -1}
        };
        int state = 0;
        for (char ch : s) {
            if (ch == ' ') state = tansfer[state][0];
            else if (ch == '+' || ch == '-') state = tansfer[state][1];
            else if (isdigit(ch)) state = tansfer[state][2];
            else if (ch == '.') state = tansfer[state][3];
            else if (ch == 'E' ||  ch == 'e') state = tansfer[state][4];
            else state = -1;
            if (state == -1) return false;
        }
        return state == 2 || state == 3 || state == 7 || state == 8;
        
    }
};
剑指 Offer 25. 合并两个排序的链表
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* begin = new ListNode(-1), *index = begin;
        ListNode* index_l1 = l1, *index_l2 = l2;
        while (index_l1 != NULL && index_l2 != NULL) {
            if (index_l1->val < index_l2->val) {
                index->next = index_l1;
                index = index->next;
                index_l1 = index_l1->next;
            } else {
                index->next = index_l2;
                index = index->next;
                index_l2 = index_l2->next;
            }
        }
        if (index_l1 != NULL) {
            index->next = index_l1;
        } 
        if (index_l2 != NULL) {
            index->next = index_l2;
        }
        return begin->next;
    }
};
剑指 Offer 30. 包含min函数的栈
class MinStack {
public:
    stack<int> sk;
    stack<int> sk_m;
    /** initialize your data structure here. */
    MinStack() {
        sk_m.push(INT_MAX);
    }
    
    void push(int x) {
        sk.push(x);
        sk_m.push(std::min(x, sk_m.top()));
    }
    
    void pop() {
        sk.pop();
        sk_m.pop();
    }
    
    int top() {
        return sk.top();
    }
    
    int min() {
        return sk_m.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->min();
 */
剑指 Offer 31. 栈的压入、弹出序列
class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        int len = pushed.size(), index = 0;
        // vector<int> mp;
        // for (int i = 0; i < len; i++) {
        //     mp[pushed[i]] = i;
        // }
        // for (auto& ch : popped) {

        // }
        stack<int> sk;
        for (int i = 0; i < len; i++) {
            sk.push(pushed[i]);
            while (index < len && !sk.empty() && popped[index] == sk.top()) {
                index++;
                sk.pop();
            }
        }
        return index == len ? true : false;
    }
};
剑指 Offer 33. 二叉搜索树的后序遍历序列
class Solution {
public:
    bool verifyPostorder(vector<int>& postorder) {

        int root = INT_MAX;
        stack<int> sk;
        for (int i = postorder.size() - 1; i >= 0; i--) {
            if (postorder[i] > root) {  //如果左子树大于root 判false
                return false;
            }
            while (!sk.empty() && postorder[i] < sk.top()) {    //如果比直接根节点小 则右边的节点pop 直接根节点作为root
                root = sk.top();
                sk.pop();
            }
            sk.push(postorder[i]);          // 其他子树入栈，右子树直接入栈 
        }
        return true;
    }
};
剑指 Offer 35. 复杂链表的复制
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
public:
    unordered_map<Node*, Node*> mp;
    Node* copyRandomList(Node* head) {
        //递归加哈希
        if (head == NULL) {
            return NULL;
        }
        if (!mp.count(head)) {
            Node* node = new Node(head->val);
            mp[head] = node;
            node->next = copyRandomList(head->next);
            node->random = copyRandomList(head->random);
        }
        return mp[head];
    }
};
剑指 Offer 46. 把数字翻译成字符串
class Solution {
public:
    int translateNum(int num) {
        //dp[i] = dp[i-1] + substr(string(dp[i - 1] + dp[i]) < 26 ? dp[i - 2] : 0;
        string ans = to_string(num);
        vector<int> dp(ans.size() + 1);
        dp[0] = 1;
        if (ans.substr(0, 2) <= "25" && ans.substr(0, 2) >= "10") {
            dp[1] = 2;
        } else {
            dp[1] = 1;
        }
        for (int i = 2; i < ans.size(); i++) {
            if (ans.substr(i - 1, 2) <= "25" && ans.substr(i - 1, 2) >= "10") {
                dp[i] = dp[i - 1] + dp[i - 2];
            } else {
                dp[i] = dp[i - 1];
            }

        }
        return dp[ans.size() - 1];
    }
};
剑指 Offer 48. 最长不含重复字符的子字符串
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        //dp
        //dp[i]记录包含当前节点最长的子串
        //dp[i] = dp[i - 1] + 1 (不重复)
        //j = mp[s[i]]  dp[i] = j - i 
        int len = s.length();
        vector<int> dp(len, 0);
        unordered_map<char, int> mp;
        int ret = 0;

        for (int i = 0; i < len; i++) {
            if (i == 0) {
                dp[i] = 1;
            } else if (!mp.count(s[i])) {
                dp[i] = dp[i - 1] + 1;
            } else {
                int j = mp[s[i]];
                if (i - j > dp[i - 1]) {
                    dp[i] = dp[i - 1] + 1;
                } else {
                    dp[i] = i - j;
                }
            }
            mp[s[i]] = i;    
            ret = max(ret, dp[i]);
        }
        return ret;
    }
};
7号菜鸡选手
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【LeetCode】剑指Offer
Arthur的博客
06-19 588
LeetCode剑指Offer
leetcode剑指-Sword_finger_offer:剑指offer思路及代码(leetcode版，C++)
07-07
《剑指Offer：LeetCode版C++实现》 在编程面试中，《剑指Offer》是一本备受推崇的书籍，它涵盖了各种经典的算法和数据结构问题，旨在帮助求职者准备技术面试。而“Sword_finger_offer”项目是将这本书中的问题转化...
算法-leetcode-剑指offer上的题很多
06-20
非常好的算法书，讲解很详细，有C++/JAVA/Python代码，很多都是leetcode上的题解，非常高清，值得下载，如果很好，请给好评，让更多人看到节约他们找资料的时间，谢谢。
leetcode中剑指offer的习题 C++语言实现（1）
大琪子的博客
03-04 193
面试题5 替换空格 第一种方法使用str的成员函数replace来完成。 第二种方法先创建一个容量足够大的string，然后将源字符串中的元素一个一个加进去，如果遇到空格，则加入%20. 因为返回值是string需要调用构造函数，但是返回值后，局部变量将被销毁，所以调用std::move()将返回值转化为右值，使其调用移动构造函数，可以提高运行速度。 // #include<algorit...
leetcode加剑指offer
weixin_41218106的博客
05-21 689
记住三条: 1.代码规范性,缩进,变量命名, 2.代码完整性,考虑所有边界输入 3.代码鲁棒性,考虑出错处理,防御性编程 另外三条: 1.功能测试 2.边界测试 3.错误输入 https://github.com/0voice/interview_internal_reference https://blog.csdn.net/u013457167/article/details/82814413?utm_source=distribute.pc_relevant.none-task C++面试题 http
LeetCode上新出的《剑指offer》
virgilshi的博客
03-06 342
文章目录面试题03. 数组中重复的数字面试题04. 二维数组中的查找面试题05. 替换空格面试题06. 从尾到头打印链表 面试题03. 数组中重复的数字 找出数组中重复的数字。 在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。 解题思路： 初步思考本题有3种做法...
[leetcode]剑指offer(C++版题解)
qq_52608074的博客
04-12 2358
剑指offer第一天剑指 Offer 09. 用两个栈实现队列剑指 Offer 30. 包含min函数的栈有待更新。。。。 第一天 剑指 Offer 09. 用两个栈实现队列 ->点这里进入leetcode 这道题的意思就是让我们使用两个栈实现一个队列， 简单复习一下： 栈：先进后出（栈顶进出元素） 队列：先进先出（队列头出元素，队列尾进元素） 我们会发现栈可以做到队列尾进元素，但是如何让栈底出元素是一个问题 我们会想到将一个栈的元素依次出栈放到另外一个栈中的时候，他的元素是不是会倒过来，例如：
【leetcode】剑指offer专项突击版详解（C++）
froot的博客
12-02 2613
题目所在链接： leetcode剑指offer专项突击版 1. 整数 剑指 Offer II 002. 二进制加法 class Solution { public: string addBinary(string a, string b) { int carry = 0; string res; int i = a.size() - 1; int j = b.size() - 1; while(i >= 0 ||
LeetCode 剑指 Offer II 栈 专题总结
2401_84411097的博客
04-19 1072
我还通过一些渠道整理了一些大厂真实面试主要有：蚂蚁金服、拼多多、阿里云、百度、唯品会、携程、丰巢科技、乐信、软通动力、OPPO、银盛支付、中国平安等初，中级，高级Java面试题集合，附带超详细答案，希望能帮助到大家。还有专门针对JVM、SPringBoot、SpringCloud、数据库、Linux、缓存、消息中间件、源码等相关面试题。《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！” />
leetcode-cpp_leetcode_C++_算法_源码分析_剑指offer_
09-30
《leetcode-cpp_leetcode_C++_算法_源码分析_剑指offer_》这份压缩包文件，主要聚焦于C++编程语言在解决LeetCode算法问题和解析《剑指Offer》中的经典面试题目的实践与分析。LeetCode是一个在线平台，提供了大量的...
leetcode答案-JS-JavaScript-Straight-towards-Offer:LeetCode剑指offerjs/JS实现&
06-30
《剑指offer》系列题解，随手记录一下自己的解题之路。 本仓库为了帮助和我一样有快速刷题需求的同学 内容简单直接，会包括《剑指offer》中所有题目的JS版本解答以及相应的简单思路，希望能够帮助到大家！ 本人的...
leetcode迷宫问题-LeetCode:LeetCode刷题之剑指offer系列
06-30
剑指offer系列题目列表（C++实现） 题目名称和题号 题目链接 题目博客 刷题次数 类型 面试题01.06：字符串压缩 +2 查找+双指针 面试题03：数组中重复的数字 +2 查找 面试题04：二维数组中的查找 +2 有序矩阵查找 ...
LeetCode:剑指offer编程每日任务
03-16
《LeetCode:剑指Offer编程每日任务》是一个旨在提升编程技能和算法理解的在线平台，特别适合准备面试或想要深入学习编程的人群。LeetCode提供了丰富的编程挑战，涵盖了多种编程语言，包括但不限于Java、C++、Python...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 914
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 389
C++ | Leetcode C++题解之第283题移动零
LeetCode707 设计链表
daishabby2486的博客
07-25 680
LeetCode707 设计链表的解题记录。
力扣202.快乐数
最新发布
gyj215500的博客
07-25 357
主要是用到了鸽巢原理，最后他们一定会重合，我们只需要判断类似，链表的成环相遇的时候是不是1就行了。
对链表的头结点和各个指向结点的引用的理解。力扣24题，两两交换链表中的结点。
qq_52983535的博客
07-23 398
其实是知道在链表前面添加一个没有实际存储内容的头结点是有利于程序运行的，但是在实际编程中总是会忘记或者不知道到底起到什么样的作用，或许这就是纸上得来终觉浅，绝知此事要躬行吧。力扣24题要求我们两两交换链表中的结点。在这种情况就很需要有一个头结点，因为考虑到交换两个头结点的时候往往不单单会只用到被交换的两个结点，往往还需要考虑被交换的第一个结点的前一个结点，因为也需要把它的next指针改变。如果设置待被交换的两个结点按顺序分别是cur和next，那么cur前面的结点就是叫pre。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值