剑指offer刷题笔记--Num61-68

已于 2023-08-07 15:04:11 修改
阅读量226 收藏
点赞数
分类专栏： 数据结构&LeetCode 文章标签： c++ 算法
于 2023-08-02 00:19:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43863869/article/details/132053152
版权

目录

1--扑克牌中的顺子（61） 

2--圆圈中最后剩下的数字（62）

3--股票的最大利润（63）

4--求1+2+...+n（64）

5--不用加减乘除做加法（65）

6--构建乘积数组（66）

7--把字符串转换成整数（67）

8--二叉搜索树的最近公共祖先（68-I）

9--二叉搜索树的最近公共祖先（68-II）

1--扑克牌中的顺子（61） 

主要思路：

        五个数是顺子的充要条件：① 最大值 - 最小值 < 5（大小王除外）；② 没有出现重复的值（大小王除外）；

        判断是否出现重复的值可以借助 set 容器；

#include <iostream>
#include <vector>
#include <set>

class Solution {
public:
    bool isStraight(std::vector<int>& nums) {
        int max = -1, min = 14; // 初始化最大值和最小值
        for(int num : nums){
            if (num == 0) continue; // 跳过大小王
            if(S.find(num) != S.end()) return false;
            else S.insert(num);
            // 更新最大值和最小值
            max = std::max(max, num); 
            min = std::min(min, num);
            if ((max - min) >= 5) return false; 
        }
        return true;
    }
private:
    std::set<int> S;
};

int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> test = {1, 2, 3, 4, 5};
    bool res = S1.isStraight(test);
    if(res) std::cout << "true" << std::endl;
    else std::cout << "false" << std::endl;
    return 0;
}

2--圆圈中最后剩下的数字（62）

主要思路：

     直观思路是借助于环形队列或者是环形链表，但需要遍历每一个数，会出现超时的现象；   

// 超时
#include <iostream>
#include <queue>

class Solution {
public:
    int lastRemaining(int n, int m) {
        std::queue<int> q;
        for(int i = 0; i < n; i++) q.push(i);
        while(q.size() != 1){
            for(int j = 1; j < m; j++){
                int tmp = q.front();
                q.pop();
                q.push(tmp);
            }
            q.pop();
        }
        return q.front();
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int n = 10, m = 17;
    int res = S1.lastRemaining(n, m);
    std::cout << res << " ";
    return 0;
}

        本题是经典的约瑟夫环问题，可通过动态规划解决；

        需要抓住的核心思想是，f(n, m) 和 f(n-1, m) 实质上是同一个数，只不过这个数在 n 序列 和 n - 1 序列中对应的编号不一样，因此需要求出两个编号的对应关系； 

// 超时
#include <iostream>

class Solution {
public:
    int lastRemaining(int n, int m) {
        int dp = 0; // dp[1] = 0;
        for(int i = 2; i <= n; i++){
            dp = (dp + m) % i; // f[i] = (f[i-1] + m) % i;
        }
        return dp;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int n = 10, m = 17;
    int res = S1.lastRemaining(n, m);
    std::cout << res << " ";
    return 0;
}

3--股票的最大利润（63）

主要思路：

        本题只能一次买入和买出，因此直观地只需要计算最大利润，即卖出的价格高，买入的价格低，且买入要在卖出之前，可以采用双指针来遍历，也可以采用动态规划来计算；

        定义 dp[i] 表示第 i 天的最大利润，则 dp[i] 与当天卖出得到的利润，以及前一天 dp[i-1]的最大利润有关 (前i - 1天已完成买入和卖出的操作)；

#include <iostream>
#include <vector>

class Solution {
public:
    int maxProfit(std::vector<int>& prices) {
        if(prices.size() <= 1) return 0;

        int dp = 0; // 初始化 dp 为 0, 表示第一天完成买入和卖出，利润为0
        int buy = prices[0]; // 初始化买入的时间
        for(int i = 1; i < prices.size(); i++){    
            // 计算在第 i 天卖出的利润
            int sell = prices[i]; 
            int profit = sell - buy;
            // 更新最大利润
            if (profit > dp) dp = profit;

            // 更新买入的时间
            if(prices[i] < buy) buy = prices[i]; 
        }
        return dp;
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    std::vector<int> test = {7, 1, 5, 3, 6, 4};
    int res = S1.maxProfit(test);
    std::cout << res << " ";
    return 0;
}

4--求1+2+...+n（64）

主要思路：

        利用逻辑运算符的短路性质来确定递归出口；

#include <iostream>

class Solution {
public:
    int sumNums(int n) {
        // 利用逻辑运算符的短路性质来确定递归出口
        // 当 n <= 0 时，逻辑运算符将 n += sumNums(n - 1) 短路，从而结束递归
        bool x = (n > 1) && (n += sumNums(n - 1));
        return n;; 
    }
};

int main(int argc, char *argv[]){
    Solution S1;
    int test = 3;
    int res = S1.sumNums(test);
    std::cout << res << std::endl;

    return 0;
}

5--不用加减乘除做加法（65）

主要思路：

        将整数 a 和 b 的和，拆分为 a 和 b 的无进位加法结果与进位结果的和；

        当进位结果为0时，结束加法；

#include <iostream>

class Solution {
public:
    int add(int a, int b) {
        while(b != 0){
            int c = ((a & b) << 1); // 进位
            a = a ^ b; // 无进位和
            b = c; // 更新b，相当于不断执行 (无进位和 + 进位)
        }
        return a; 
    }
};

int main(int argc, char *argv[]){
    int a = 1, b = 1;
    Solution S1;
    int res = S1.add(a, b);
    std::cout << res << std::endl;

    return 0;
}

6--构建乘积数组（66）

主要思路：

        对于位置 i 的元素，使用 L 存储其左边元素（[0, i - 1]）的乘积，使用 R 存储其右边元素的乘积([i + 1, len - 1])；

        最后将 L 和 R 进行乘积并返回即可；

#include <iostream>
#include <vector>
 
class Solution {
public:
    std::vector<int> constructArr(std::vector<int>& a) {
        if(a.size() <= 1) return a;

        std::vector<int> L = {1};
        for(int i = 1; i < a.size(); i++){ 
            L.push_back(L[i - 1] * a[i - 1]); // 存储左边的乘积
        }
        int R = 1;
        for(int j = a.size() - 2; j >= 0; j--){
            R = R * a[j+1]; // 存储右边的乘积
            L[j] = L[j] * R; // 更新最终的结果
        }
        return L;
    }
}; 
 
int main(){
    std::vector<int> test = {1, 2, 3, 4, 5};
    Solution S1;
    std::vector<int> res = S1.constructArr(test);
    for(int num : res){
        std::cout << num << " ";
    }
 
    return 0;
}

7--把字符串转换成整数（67）

主要思路：

        主要难点在于确定边界条件，防止越界；

#include <iostream>
#include <string>

#define INT_MAX 2147483647
#define INT_MIN -2147483648

class Solution {
public:
    int strToInt(std::string str) {
        if(str.length() <= 0) return 0;

        // 去除前面的空格
        int i = 0;
        while(i < str.length() && str[i] == ' ') i++;

        // 判断第一个字符
        int sign = 1;
        int res = 0;
        if(str[i] == '-'){
            sign = -1; // 负数
            i++;
        }
        else if(str[i] == '+'){
            sign = 1; // 正数
            i++;
        }
        else if(str[i] < '0' || str[i] > '9') return 0; // 非数

        for(; i < str.length(); i++){
            if(str[i] < '0' || str[i] > '9') break;
            if(res > (INT_MAX / 10) || res == (INT_MAX / 10) && str[i] > '7'){
                return sign == 1 ? INT_MAX : INT_MIN;
            }
            int tmp = (str[i] - '0');
            res = res * 10 + tmp;
        }
        return sign * res;
    }
};
 
int main(){
    std::string test = "   -42";
    Solution S1;
    int res = S1.strToInt(test);
    std::cout << res << std::endl;
    return 0;
}

8--二叉搜索树的最近公共祖先（68-I）

主要思路：

        题目提供的是二叉搜索树，即左子树的值比根节点小，右子树的值比根节点大；

        假设 p 和 q 分别在某个根节点的左右子树，则其最近公共祖先为当前根节点；

        假设 p 和 q 处在某个根节点的同一颗子树上，需要遍历下一层来判断，直到 p 和 q 不满足在同一颗子树上；

#include <iostream>
#include <vector>

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) {
        while(root){
            // p 和 q 都处在右子树
            if(p->val > root->val && q->val > root->val) root = root->right;
            // p 和 q 都处在左子树
            else if(p->val < root->val && q->val < root->val) root = root->left;
            // 结束遍历
            else break;
        }
        return root;
    }
};

int main(){
    // root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
    TreeNode *Node1 = new TreeNode(6);
    TreeNode *Node2 = new TreeNode(2);
    TreeNode *Node3 = new TreeNode(8);
    TreeNode *Node4 = new TreeNode(0);
    TreeNode *Node5 = new TreeNode(4);
    TreeNode *Node6 = new TreeNode(7);
    TreeNode *Node7 = new TreeNode(9);
    TreeNode *Node8 = new TreeNode(3);
    TreeNode *Node9 = new TreeNode(5);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;
    Node5->left = Node8;
    Node5->right = Node9;

    Solution S1;
    TreeNode *res = S1.lowestCommonAncestor(Node1, Node2, Node3);
    std::cout << res->val << std::endl;

    return 0;
}

9--二叉搜索树的最近公共祖先（68-II）

主要思路：

        与上题不同，本题提供的是普通二叉树；核心思路是使用深度递归搜索节点 p 和 节点 q，返回其对应的节点；当节点 p 和 节点 q 分属某个根节点的左右子树时，这个根节点是其最近祖先（因为回溯是自底向上，首先遇到的肯定是最近祖先）；

        需要注意的是，当在一颗子树找到某一个节点时，是直接返回该节点，无需在同一个子树搜索另一个节点；因为只需要回溯判断上一层，看看另一个节点是否在另一颗子树上即可；如果另一个节点在另一颗子树，则上一层的根节点是最近祖先；如果另一个节点不在另一颗字树上，则另一个节点肯定在刚刚直接返回节点的那颗子树上（即没有继续搜索的那一颗），此时返回节点必定是最近祖先（即节点和最近祖先是同一个节点）；（写得有点乱，细想一下就理解了）；

#include <iostream>
#include <vector>

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 == NULL || root->val == p->val || root->val == q->val) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q); // 从左子树找节点
        TreeNode* right = lowestCommonAncestor(root->right, p, q); // 从右子树节点
        if(left != NULL && right != NULL){ // p和q分别在root的左右子树上
            return root;
        }
        else if(left != NULL && right == NULL){ // p和q不在root的右子树上
            return left; // 返回找到的节点位置
        }
        else if(left == NULL && right != NULL){ // p和q不在root的左子树上
            return right; // 返回找到的节点位置
        }
        else return NULL;
    }
};

int main(){
    // root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
    TreeNode *Node1 = new TreeNode(3);
    TreeNode *Node2 = new TreeNode(5);
    TreeNode *Node3 = new TreeNode(1);
    TreeNode *Node4 = new TreeNode(6);
    TreeNode *Node5 = new TreeNode(2);
    TreeNode *Node6 = new TreeNode(0);
    TreeNode *Node7 = new TreeNode(8);
    TreeNode *Node8 = new TreeNode(7);
    TreeNode *Node9 = new TreeNode(4);

    Node1->left = Node2;
    Node1->right = Node3;
    Node2->left = Node4;
    Node2->right = Node5;
    Node3->left = Node6;
    Node3->right = Node7;
    Node5->left = Node8;
    Node5->right = Node9;

    Solution S1;
    TreeNode *res = S1.lowestCommonAncestor(Node1, Node2, Node3);
    std::cout << res->val << std::endl;

    return 0;
}

剑1 end in 2023.08.07. (~v~)

晓晓纳兰容若
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指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刷题笔记
11-08
剑指offer刷题笔记（一），大概完成40多道题，语言c++,python,java
剑指offer刷题笔记--Num51-60
牵一只蜗牛去散步
07-19 969
考虑到题目给定的数组是递增有序的，因此可以考虑使用双指针法，分别指向数组的左右两端，并计算双指针指向值的和，当和小于 target 时，左指针右移，当和大于 target 时，右指针左移，当和等于 target 时，返回结果；出现三次的数字，在二进制位中其对应位肯定是 3 的倍数，因此只需统计 32 位整型中 1 出现的次数，并将其整除 3，就可以得到只出现1次的数字在该位的数值；相同的两个数进行异或，其结果为零（与顺序无关），因此在题目的数组中，遍历所有元素进行异或，得到的最终结果为。
剑指offer刷题笔记--Num41-50
牵一只蜗牛去散步
07-10 373
使用快排对字符串数组进行排序，要确保由字符串数组组成的数最小，即strs[0]strs[1]strs[2]...最小，必须连续满足strs[0] < strs[1], strs[1] < strs[2];基于无序哈希表，key为字符，value 为该字符是否唯一，遍历字符串，当字符唯一时，value 设为 true，否则设为 false；转移方程：dp[i][j] = grid[i][j] + max(dp[i-1][j], dp[i][j-1]);维护两个优先队列，Q1大数优先，存储比中位数小的数；
剑指offer刷题笔记--Num31-40
牵一只蜗牛去散步
07-04 294
直观思路：用两个指针 i 和 j 指向压入和弹出的 vector，终止条件是：所有元素都压入了辅助栈（i > len），且辅助栈当前的栈顶元素与弹出的元素 popped[j] 不相等；模拟栈的压入顺序，依次压入 pushed 里的所有元素，用一个指针 j 指向需要弹出的元素，当符合弹出要求时就弹出对应的元素；二叉搜索树的定义：左子树的结点均小于根节点，右子树的结点均大于根结点；，不同的是为了打印每一层的结点，需要循环当前层的结点数次，每一次。，因此只需要循环队列的长度次，并记录对应的结点值即可；
剑指offer刷题笔记--Num11-20
牵一只蜗牛去散步
05-29 382
对于一段长度为 n 的绳子，将其最大乘积定义为 dp[n]，当裁剪出一段长度为 2 或 3 的绳子后，有两种情况：继续裁剪，则 dp[n] = 2 * dp[n - 2] 或 3 * dp[n - 3]；基于动态规划，则状态转移方程为：dp[n] = max(max(2 * dp[n-2], 2 * (n -2)), max(3*dp[n - 3], 3 * (n - 3)))；每段绳子的长度 k 必须是 2 或 3，因为当 k>= 4时，可以进一步裁剪，例如长度 5 可以拆分为 2*3 大于 5；
剑指offer刷题笔记--Num21-30
牵一只蜗牛去散步
06-26 333
想象成环形链表，反转链表的实质上结点指向上一个结点，则只需遍历链表，将当前结点指向上一个结点，不断更新当前结点和上一个结点即可；由于左右指针的间距为k，则左指针指向原链表的倒数第 k 个节点，直接返回即可；双指针法，左指针从 0 开始遍历，直到遇到偶数，右指针从 len - 1 开始遍历，直到遇到奇数；递归判断左子树的左子树与右子树的右子树是否相等，左子树的右子树与右子树的左子树是否相等；这时左指针指向偶数，右指针指向奇数，交换两个指针的数值，并继续判断下一组数；4--合并两个排序的链表（25）
剑指Offer刷题笔记--Num03-10
牵一只蜗牛去散步
05-06 95
如果0索引没有专业对口，那么我们看现在0索引上的人才调整到他对应的岗位上，比如num[0]=2，那我们就把2这个元素挪到他对应的岗位上既num[2]，这个时候有两种情况:1、num[2]岗位上已经有专业对口的人才了，既num[2]=2，这就说明刚刚那个在num[0]上的2是溢出的人才，我们直接将其返回即可。经典动态规划题目，使用递归会导致内存消耗大、运行时间长等问题，利用递推的方式实现求解：从 F(2) = F(1) + F(0) 开始递推，利用变量记录当前的F(N-1)和F(N-2)；
剑指offer刷题笔记-篇2
qq_45966201的博客
05-08 817
按照《剑指offer》顺序的刷题笔记，每周积累算法题，主要刷题平台为牛客网，部分题目使用的刷题平台为LeetCode和Acwing，每题均包含主要思路、详细注释、时间复杂度和空间复杂度分析，每题均是尽可能最佳的解决办法。
剑指offer刷题笔记-Java实现
Skeletonz的博客
06-05 562
1.找出数组中重复的数字 给定一个长度为 n 的整数数组 nums，数组中所有的数字都在 0∼n−1 的范围内。 数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。 请找出数组中任意一个重复的数字。 注意：如果某些数字不在 0∼n−1 的范围内，或数组中不包含重复数字，则返回 -1； 样例 给定 nums = [2, 3, 5, 4, 3, 2, 6, 7]。 返回 2...
剑指offer刷题笔记-不晓得第几天了
寻宝游戏
03-30 255
矩阵中的路径（medium） 请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一格开始，每一步可以在矩阵中向左、右、上、下移动一格。如果一条路径经过了矩阵的某一格，那么该路径不能再次进入该格子。例如，在下面的3×4的矩阵中包含一条字符串“bfce”的路径（路径中的字母用加粗标出）。 [["a","b","c","e"], ["s","f","c",...
剑指offer刷题笔记.zip
05-13
这个压缩包“剑指offer刷题笔记.zip”显然包含了作者对这些面试题的解题思路、算法分析以及相关知识点的详细笔记。以下是对这些知识点的详细阐述： 1. **数据结构与算法** - **数组**：在《剑指Offer》中，数组是...
剑指offer:17-20
12-22
【知识点详解】 1. **树的子结构** (第17题) - 在这个问题中，我们需要判断一棵二叉树B是否是另一棵二叉树A的子结构。首先，我们要遍历树A，寻找与树B根节点值相同的节点R。如果找到，我们将以R为根的子树与树B...
leetcode答案-OfferCodingPractice:剑指OFFER刷题记录
06-30
剑指Offer leetcode刷题代码 为本人练习记录学习所作 com.hackhu 原本 包下为2014版 剑指Offer 刷题代码 ： 数据结构篇 数据结构系列包括：数组、字符串、链表、栈&队列、Hash、树、堆以及位运算。 数据结构篇的主要...
C++ 多态
最新发布
wxk2227814847的博客
07-10 764
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
初始C++
2302_81016149的博客
07-08 809
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
C++初探究（2）
Frenemy__的博客
07-09 1479
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1015
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值