剑指offer_知识迁移能力

最新推荐文章于 2024-08-18 17:01:18 发布
最新推荐文章于 2024-08-18 17:01:18 发布
阅读量113 收藏
点赞数
分类专栏： # leetcode学习 文章标签： 算法 leetcode 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xywams/article/details/125583738
版权

知识迁移能力

剑指 Offer 53 - I. 在排序数组中查找数字 I

题目

在这里插入图片描述

代码

class Solution {
public:
    //寻找右边界
    int searchrb(vector<int>& nums, int target) {
        int sz = nums.size();
        int left = 0, right = sz - 1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] <= target) {
                left = mid + 1;
            }else  {
                right = mid - 1;
            }
        }
        return left;
    }
    int search(vector<int>& nums, int target) {
        //二分法，找到目标数字的左右边界,或者查找target和target-1的右边界
        return searchrb(nums, target) - searchrb(nums, target - 1);
    }
};

剑指 Offer 53 - II. 0～n-1中缺失的数字

题目

在这里插入图片描述

代码

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        //二分法
        int sz = nums.size();
        int left = 0, right = sz - 1;
        while(left <= right) {
            int mid = left + (right - left) / 2;
            if(nums[mid] == mid) {
                left = mid + 1;
            }else {
                right = mid - 1;
            }
        }
        return left;
    }
};

剑指 Offer 54. 二叉搜索树的第k大节点

题目

在这里插入图片描述

代码

法一：中序遍历+vector存值

/**
 * 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:
    int sz = 0;
    vector<int> walk;
    void re(TreeNode* root) {
        if(root == nullptr) {
            return;
        }
        re(root->left);
        walk.push_back(root->val);
        sz++;
        re(root->right);
    }
    int kthLargest(TreeNode* root, int k) {
        //前遍历的倒数第三个节点
        re(root);
        return walk[sz - k];
    }
};

法二：
中序遍历倒着来,右根左

/**
 * 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:
    int res;
    void re(TreeNode* root, int& k) {
        if(root == nullptr) {
            return;
        }
        re(root->right, k);
        k--;
        if(k == 0) {
            res = root->val;
            return ;
        }
        re(root->left, k);
    }
    int kthLargest(TreeNode* root, int k) {
        //前遍历的倒数第三个节点
        re(root, k);
        return res;
    }
};

剑指 Offer 55 - 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:
    int dfs(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        int l = dfs(root->left);
        int r = dfs(root->right);
        //最大深度等于左子树和右子树深度额较大值加一
        return max(l,r) + 1;
    }
    int maxDepth(TreeNode* root) {
        //递归
        return dfs(root);
    }
};

剑指 Offer 55 - II. 平衡二叉树

题目

在这里插入图片描述

代码

方法一：

/**
 * 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 flag = true;
    int depth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        int ld = depth(root->left);
        int rd = depth(root->right);
        if(ld - rd > 1 || rd - ld > 1) {
            flag = false;
        }
        return max(ld, rd) + 1;
    }
    bool isBalanced(TreeNode* root) {
        depth(root);
        return flag;
    }
};

方法二：
剪枝

/**
 * 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:
    int depth(TreeNode* root) {
        if(root == nullptr) {
            return 0;
        }
        int ld = depth(root->left);
        if(ld == -1) {
            return -1;
        }
        int rd = depth(root->right);
        if(rd == -1) {
            return -1;
        }
        if( ld - rd > 1 || rd - ld > 1 ) {
            return -1;
        }else {
            return max(ld, rd) + 1;
        }
    }
    bool isBalanced(TreeNode* root) {
        if(depth(root) != -1) {
            return true;
        }else 
        return false;
    }
};

剑指 Offer 56 - I. 数组中数字出现的次数

题目

在这里插入图片描述

代码

class Solution {
public:
    vector<int> singleNumbers(vector<int>& nums) {
        //异或也太妙了
        int z = 0;
        for(auto num: nums) {
            //z就是两个目标数字的异或值
            z = z ^ num;
        }
        int m = 1;
        //找到z中为1的位
        while((m & z) == 0) {
            m <<= 1;
        }
        int a = 0, b = 0;
        for(auto num : nums) {
            //num & m可以把数组分为两部分,两个单独的数字一定会被分开
            if(num & m) {
                a = a ^ num;
            }else {
                b = b ^ num;
            }
        }
        return vector<int>{a, b};
    }
};

剑指 Offer 56 - I. 数组中数字出现的次数

题目

在这里插入图片描述

代码

方法：有限状态机
在这里插入图片描述
不是很懂

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        int one = 0, two = 0;
        for(auto num : nums) {
            one = one ^ num & ~two;
            two = two ^ num & ~one;
        }
        return one;
    }
};

剑指 Offer 57. 和为s的两个数字

题目

在这里插入图片描述

代码

能做出来

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int sz = nums.size() ;
        int left = 0, right = sz - 1;
        vector<int>res;
        while(left < right) {
            if(nums[left] + nums[right] == target) {
                res.push_back(nums[left]);
                res.push_back(nums[right]);
                return res;
            }else if(nums[left] + nums[right] < target) {
                left++;
            }else 
                right--;
        }
        return res;
    }
};

剑指 Offer 57 - II. 和为s的连续正数序列

题目

在这里插入图片描述

代码

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        //用滑动窗口,考虑窗口内所有值
        vector<vector<int>>res;
        //s是元素和
        int left = 1, right = 2, s = 3;
        while(left < right) {
            if(s == target) {
                vector<int>ans;
                for(int i = left; i <= right; i++) {
                    ans.push_back(i);
                }
                res.push_back(ans);
            }
            if(s >= target) {
                //左边界向右移动
                s = s - left;
                left ++;
            }else {
                //右边界向右移动
                right++;
                s = s + right;
            }
        }
     return res;
    }
};

剑指 Offer 58 - I. 翻转单词顺序

题目

在这里插入图片描述

代码

感觉不太会。。。
方法：双指针、倒序

class Solution {
public:
    string reverseWords(string s) {
        //忽略头和尾部的空格
        string res;
        int sz = s.size();
        int right = sz - 1;
        while(right >= 0) {
            //从后往前寻找第一个字符
            while(s[right] == ' ') {
                right--;
            }
            //寻找第一个空格
            int left = right;
            while(left >= 0 && s[left] != ' ' ) {
                left--;
            }
            //添加单词
            res = res + s.substr(left + 1, right - left);
            res = res + ' ';
            //继续往前找
            right = left;
        }
         //去除最后一个字符多加的空格
         if(!res.empty()) {
                res.pop_back();
            }
        return res;
    }
};

剑指 Offer 58 - II. 左旋转字符串

题目

在这里插入图片描述

代码

法一：自己写的，用时和空间消耗都很大

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        //左旋n个字母，按顺序把开头的n个字母依次放到最后
        int sz = s.size() - 1;
        for(int i = 0; i < n; i++) {
            s = s + s[i];
        }
        return s.substr(n, sz + n);
    }
};

法二：两部分用substr()拼接起来

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        return s.substr(n, s.size() - 1 + n) + s.substr(0, n);
    }
};

法三：遍历拼接加取余

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string res = string(s);
        int len = s.length();
        for(int i =0 ;i<len;++i){
            res[(i+len-n)%len]=s[i];
        }
        return res;
    }
};

剑指 Offer 59 - I. 滑动窗口的最大值

题目

代码

法一：单调队列
deque 内的元素非严格递减

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int sz = nums.size();
        vector<int> res;
        if(sz == 0) {
            return res;
        }
        res.resize(sz - k + 1);
        deque<int>dq;
        //还未形成窗口
        for(int i = 0; i < k; i++) {
            //如果双端队列末尾的元素小于当前元素，弹出
            while(!dq.empty() && dq.back() < nums[i]) {
                dq.pop_back();
            }
            dq.push_back(nums[i]);
        }
        //已经形成窗口
        //这一步不能忘
        res[0] = dq.front();
        for(int i = k; i < sz; i++) {
            //队首元素等于被删除元素，弹出
            if(dq.front() == nums[i - k]) {
                dq.pop_front();
            }
            while(!dq.empty() && dq.back() < nums[i]) {
                dq.pop_back();
            }
            dq.push_back(nums[i]);
            res[i - k + 1] = dq.front();
        }
        return res;
    }
};

方法二：
对于「最大值」，我们可以想到一种非常合适的数据结构，那就是优先队列（堆），其中的大根堆可以帮助我们实时维护一系列元素中的最大值。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        //优先队列，大根堆,存入数组元素及其索引
        priority_queue<pair<int, int>>pq;
        int sz = nums.size();
        vector<int> res;
        if(sz == 0) {
            return res;
        }
        for(int i = 0; i < k; i++) {
            pq.push({nums[i], i});
        }
        res.push_back({pq.top().first});
        for(int i = k; i < sz; i++) {
            pq.push({nums[i], i});
            //弹出滑出窗口的元素
            while(pq.top().second <= i - k) {
                pq.pop();
            }
            res.push_back(pq.top().first);
        }
        return res;
    }
};

剑指 Offer 59 - II. 队列的最大值

题目

在这里插入图片描述

代码

本算法基于问题的一个重要性质：当一个元素进入队列的时候，它前面所有比它小的元素就不会再对答案产生影响。
咱也不知这个均摊时间复杂度都是O(1)要怎么看

class MaxQueue {
public:
    queue<int>q;
    //双端单调队列
    deque<int>dq;
    MaxQueue() {
        
    }
    
    int max_value() {
        if(q.empty()) {
            return -1;
        }
        return dq.front();
    }
    
    void push_back(int value) {
        //弹出小于value的值
        while(!dq.empty() && dq.back() < value) {
            dq.pop_back();
        }
        dq.push_back(value);
        q.push(value);

    }
    
    int pop_front() {
         if(q.empty()) {
            return -1;
        }
        int res = q.front();
        //q队首元素要么是dq的队首元素，要么是已经被dq弹出的元素
        if(res == dq.front()) {
            dq.pop_front();
        }
        q.pop();
        return res;
    }
};

/**
 * Your MaxQueue object will be instantiated and called as such:
 * MaxQueue* obj = new MaxQueue();
 * int param_1 = obj->max_value();
 * obj->push_back(value);
 * int param_3 = obj->pop_front();
 */
xywams
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer_知识迁移
weixin_43271235的博客
05-13 87
章节目录1、数组中出现次数超过一半的数字1.1 hashmap2、二叉树的深度2.1 递归一定要注意递归退出条件3、平衡二叉树3.1 递归退出条件，空树也被认为是平衡二叉树4、数组中只出现一次的数字4.1 两次遍历+hashmap4.2 两个相同数异或结果为0，左移不需要考虑符号位，右移就需要考虑5、和为S的连续正数序列5.1 前言：当前内容只用来回忆复习，java编写，代码尽可能带注释，部分题目附上解题思路。如有错误，请指出，谢谢。 感悟：刷题重在思路以及巩固知识点，而不是刷题进度。 重点： 1、数组中出
平衡二叉树（剑指offer）知识迁移能力
寻找&星空の孩子
10-07 1215
平衡二叉树 参与人数：1135时间限制：1秒空间限制：32768K通过比例：32.36%最佳记录：0 ms|0K 题目描述 输入一棵二叉树，判断该二叉树是否是平衡二叉树。 题目链接：http://www.nowcoder.com/practice/8b3b95850edb4115918ecebdf1b4d222?rp=2&ru=/ta/coding-
【剑指Offer】知识迁移能力
果果果酱要Offer
08-06 136
数字在排序数组中出现的次数 / 二叉树的深度 / 数组中只出现一次的数字 / 和为s的两个数字 VS 和为s的连续正数序列 / 翻转单词序列 VS 左旋转字符串
剑指offer刷题记录——知识迁移能力
daizhaohuang的博客
02-28 158
二叉树的深度 题目描述 输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。 实现思路 层次遍历 具体实现 /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), le...
sword-pointing-to-offer_java.zip_剑指offer_剑指offer java
09-20
这本书的原始版本是用C++语言编写的，而"剑指offer_java.zip_剑指offer_剑指offer java"则提供了这些问题的Java实现版本。Java是一种广泛使用的面向对象的编程语言，以其平台无关性、丰富的类库和安全性著称。将这些...
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
No4_fliesdm7_familywbh_剑指offer_
10-01
【标题】"No4_fliesdm7_familywbh_剑指offer_" 指的是一个编程挑战，源自《剑指Offer》这本书中的第四道题目。《剑指Offer》是一本非常受欢迎的针对中国程序员面试的准备书籍，它包含了大量关于算法和数据结构的题目...
T43-n个筛子点数.rar_剑指offer_筛子
07-15
标题中的"T43-n个筛子点数.rar_剑指offer_筛子"指的是一个编程问题，来源于《剑指Offer》这本书，它涉及到计算多个筛子（骰子）投掷后点数之和的问题。这个问题通常出现在算法和数据结构的学习中，旨在训练面试者...
剑指offer（java版）.rar_剑指offer_剑指offer java_剑指offer（java版）
09-24
《剑指Offer》是针对Java开发者的一本面试指南，它集结了47道常见的Java面试编程...以上只是《剑指Offer》中部分重要知识点的概述，深入学习并实践这些内容，将对提升Java程序员的面试竞争力和实际工作能力大有裨益。
算法的学习笔记—删除链表中重复的结点（牛客JZ76）
业精于勤，荒于嬉
08-14 1234
本文介绍了一种删除排序链表中重复节点的高效算法。通过递归的方式，算法能够有效地删除所有重复节点，并保留链表中仅出现一次的节点。此方法的实现简单且易于理解，同时在时间和空间复杂度方面表现优异，适用于处理大规模数据链表中的重复节点问题。😁热门专栏推荐想学习vue的可以看看这个java基础合集数据库合集redis合集nginx合集linux合集手写机制微服务组件spring_尘觉springMVCmybits🤔欢迎大家加入我的社区尘觉社区。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 1163
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
【秋招笔试】8.11大疆秋招(第二套)-测开岗
清隆学长的博客
08-12 823
> 🍒 本专栏已收集 70+套笔试题，`笔试真题` 会在第一时间跟新 > > 🍹 近期会进行一波价格调整，没订阅的朋友抓紧冲！！！
LeeCode Practice Journal | Day43_DP10
Janniam的博客
08-14 283
上题的变体，与nums[i]前每一个连续的元素比较变为前一个元素比较。2、返回值不是dp[i]，是dp数组中的最大值。1、数组元素要初始化为1。
【算法】马踏棋盘（骑士周游）问题回溯算法实现以及使用贪心算法优化
2302_78914800的博客
08-18 373
将马儿随机放在国际象棋的 8*8 棋盘的某个方格中，马儿按照“马走日”进行移动，要求每个方格只进入一次，走遍棋盘上全部 64 个方格。注意：马儿不同的走法会得到不同的结果，效率也会有影响。
noip2001数的划分
最新发布
no_play_no_games的博客
08-18 73
将整数n分成k份，且每份不能为空，任意两份不能相同(不考虑顺序)。例如：n=7，k=3，下面三种分法被认为是相同的。1，1，5;1，5，1;5，1，1;问有多少种不同的分法。
24/8/18算法笔记 目标导向强化学习
yyyy2711的博客
08-18 358
初始化DDPG模型data = {'over':[],#Data采样函数#采样结果sample = {'over':[],#采样N个数据#随机一局游戏#随机游戏中的一步，这里除了最后一步#提取数据#设置fake goal#随机选择step后面的某一步#以后面某个步的状态为一个伪的终点，也就是希望先走到这里再说#求二范数mod = [#再自己重新计算reward和over#以伪终点构建新的state#计算最后10个数据reward_sum的值。
算法之递归和迭代
qq_28576837的博客
08-16 322
斐波那契数列（Fibonacci sequence），又称黄金分割数列，这个数列最早是由印度数学家提出来的。如果是用迭代，那么就是用循环从前往后计算，前两个数是固定的，先根据前两个数可以计算出第三个数，然后把第三个数和第二个数再赋值给之前的变量，再相加即可。使用递归时，如果要计算第100个数，那么要先直到第99和第98个，要知道第99个和第98个，就要分别进行递归，直到最后一层，再返回递归回来进行计算。这个序列的前几项是这样的：0,1,1,2,3,5,8,13,21,34,⋯。自然，用递归函数最容易实现。
二分查找5️⃣-山脉数组的封顶索引
2202_75331338的博客
08-15 280
对于山峰来说，我们会发现封顶的值是最大，对于封顶左边来说，后一个数比前一个数大；◦ 如果 mid 位置呈现上升趋势，说明我们接下来要在 [mid + 1, right] 区间继续搜索；◦ 如果 mid 位置呈现下降趋势，说明我们接下来要在 [left, mid - 1] 区间搜索；◦ 因此，我们可以遍历数组内的每一个元素，找到某一个元素比两边的元素大即可。本题的数组不是有序数组，但我们依然可以使用二分查找，原因是因为我们发现了。输入：arr = [0,2,1,0]◦ 峰顶的特点：比两侧的元素都要大。
剑指Offer编程题目与Java代码大全
5. 面试技巧：《剑指Offer》不仅是技术学习的资源，也包含了如何在面试中展现自己的编程技巧、沟通能力和问题解决策略。 6. 实战演练：通过解答这些题目，求职者可以在实际的面试环境中检验和提升自己的技术实力，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值