剑指Offer刷题笔记

已于 2022-03-26 11:02:10 修改
阅读量695 收藏 9
点赞数
分类专栏： leetcode 剑指Offer 数组 文章标签： 考研复试 leetcode 动态规划
于 2020-10-18 12:31:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1072118803/article/details/109143300
版权
leetcode 同时被 3 个专栏收录
58 篇文章 0 订阅
订阅专栏
数组
4 篇文章 0 订阅
订阅专栏
剑指Offer
3 篇文章 0 订阅
订阅专栏

一、数组

剑指Offer 03.数组中重复的数字

在这里插入图片描述

思路

运用了类似桶排序的思想。因为数字在0~n-1内，于是可以将值为x的元素放在下标为x的位置，如果放置时发现数组中下标为x的元素值已经是x了，则就找到了一个重复元素。
时间复杂度O(n)
空间复杂度O(1)

代码

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        int i = 0;
        int N = nums.size();
        while(i<N)
        {
            if(nums[i]!=i)
            {
                int x = nums[i];
                if(nums[i]==x)
                    return x;
                swap(nums[i],nums[x]);
            }
            else i++;
        }
        return -1;
    }
};

剑指Offer 0~n-1中缺失的数字

在这里插入图片描述

思路

显然可以使用二分法。如果mid==nums[mid]则说明缺失的数字不在0~mid（含）之中，如果mid!=nums[mid]则说明缺失的数字应在mid之后的位置。
时间复杂度O(logn)，空间复杂度O(1)。

代码

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int le = 0;
        int ri = nums.size();
        int mid;
        while(le<ri)
        {
            mid = (le+ri)/2;
            if(nums[mid]==mid)
                le = mid + 1;
            else ri = mid;    
        }
        return le;
    }
};

剑指Offer 11.旋转数组的最小值

在这里插入图片描述

思路

旋转之后的数组实际上是两个排序的子数组。

代码

class Solution {
public:
    int findmin(vector<int>& numbers, int le, int ri)
    {
        int result = numbers[le];
        for(int i=le+1; i<=ri; i++)
            if(result > numbers[i])
                result = numbers[i];
        return result;
    }
    int minArray(vector<int>& numbers) {
        int N = numbers.size();
        int le = 0;
        int ri = N-1;
        int mid = le;
        while(numbers[le] >= numbers[ri])
        {
            if(ri-le == 1)
            {
                mid = ri;
                break;
            }
            mid = (ri+le)/2;
            if(numbers[le]==numbers[ri]&&numbers[mid]==numbers[le])
                return findmin(numbers, le, ri);
            if(numbers[mid]>=numbers[le])
                le = mid;
            else if(numbers[mid]<=numbers[ri])
                ri = mid;
        }
        return numbers[mid];

    }
};

二、二叉树

剑指 Offer. 26. 树的子结构

在这里插入图片描述

思路

theSame(TreeNode* A, TreeNode* B)

作用：判断以A为根节点的子树是否与B有相同结构。

判断B是否为空：
B为空（表明树B遍历完全）返回true；
B不为空的情况下，A为空或A节点值与B不相等，表明不匹配，返回false；
若A、B均不为空且它们的值相等则表明该节点匹配，再递归判断A的左子树与B的左子树是否有相同结构，A的右子树与B的右子树是否有相同结构

isSubStrcture(TreeNode* A, TreeNode* B)

作用：判断B是否为A的子结构
先序遍历找到A中与B根节点值相等的节点，再判断以该节点为根节点的子树是否与树B拥有相同的结构（使用theSame(A, 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 isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL || B==NULL)
            return false;
        bool result = false;
        if(A->val == B->val)
            result = theSame(A, B);
        if(!result)
            result = isSubStructure(A->left, B);
        if(!result) 
            result = isSubStructure(A->right, B);
        return result;

    }
    bool theSame(TreeNode* A, TreeNode* B)
    {
        if(B == NULL)
            return true;
        if(A == NULL || A->val != B->val)
            return false;
        return theSame(A->left, B->left) && theSame(A->right, B->right);
    }
};

剑指 Offer 27. 二叉树的镜像

代码 递归

/**
 * 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 == NULL)
            return NULL;
        TreeNode* tmp  = root->left;
        root->left = mirrorTree(root->right);
        root->right = mirrorTree(tmp);
        return 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 root;
        stack<TreeNode*> st;
        st.push(root);
        while(!st.empty())
        {
            TreeNode* p = st.top();
            st.pop();
            if(p->left)
                st.push(p->left);
            if(p->right)
                st.push(p->right);
            TreeNode* tmp = p->left;
            p->left = p->right;
            p->right = tmp;
        }
        return root;
    }
};

剑指 Offer 27. 二叉树的镜像

代码 递归

/**
 * 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 isSymmetric(TreeNode* root) {
        if(root==NULL)
            return true;
        return judge(root->left, root->right);
    }
    bool judge(TreeNode* p, TreeNode* q)
    {
        if(p == NULL && q == NULL)
            return true;
        if(p == NULL || q == NULL)
            return false;
        if(p->val != q->val)
            return false;
        return judge(p->left, q->right) && judge(p->right, q->left);  
            
    }
};

剑指Offer 33. 二叉搜索树的后序遍历序列

代码

class Solution {
public:
    bool verify(vector<int>& postorder, int low, int high)
    {
        int root = postorder[high];
        //找到左子树部分
        int i = low;
        for(; i < high; i++)
        {
            if(postorder[i] > root)
                break;
        }
        int j = i;
        //判断“右子树”序列是否满足每个节点都大于等于根节点
        for(; j < high; j++)
        {
            if(postorder[j] < root)
                return false;
        }
        bool left = true;
        //递归判断左子树是否满足后序遍历条件
        if(i > low)
            left = verify(postorder, low, i-1);
        bool right = true;
        //递归遍历右子树是否满足后序遍历条件
        if(i < high)
            right = verify(postorder, i, high-1);
        return (left && right);

    }
    bool verifyPostorder(vector<int>& postorder) {
        int length = postorder.size();
        if(length==0)
            return true;
        return verify(postorder, 0, length-1);
    }
};

剑指Offer 34. 二叉树中和为某一值的路径

在这里插入图片描述
遇到一个坑点：节点值可能是负数，之前写了一句当前和大于sum提前返回的句子。

代码 回溯

/**
 * 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:
    vector<vector<int>> ans;
    int s;
    void dfs(TreeNode* root, int now, vector<int>& path)
    {
        if(!root)
            return;
        path.push_back(root->val);
        now += root->val;
        if(now == s && !root->left && !root->right)
        {
            ans.push_back(path);
            path.pop_back();
            return;
        }
        dfs(root->left, now, path);
        dfs(root->right, now, path);
        path.pop_back();
    }
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        s = sum;
        vector<int> path;
        dfs(root, 0, path);
        return ans;
    }
};

剑指 Offer 36. 二叉搜索树与双向链表

在这里插入图片描述

分析

将一个二叉搜索树转化为双向链表，完成这一功能的核心是记录下中序遍历的第一个节点以及记录下当前遍历节点的前驱prev，只需将prev的right指针指向当前节点，当前节点的left指针指向prev即可。一波中序遍历之后，还需修改头结点的前驱，使其指向中序遍历的最后一个节点，修改中序遍历最后一个节点的后驱，使其指向头结点。

代码 中序遍历

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* left;
    Node* right;

    Node() {}

    Node(int _val) {
        val = _val;
        left = NULL;
        right = NULL;
    }

    Node(int _val, Node* _left, Node* _right) {
        val = _val;
        left = _left;
        right = _right;
    }
};
*/

class Solution {
public:
    Node* head = NULL;
    Node* prev = NULL;
    void inorder(Node* root)
    {
        if(root->left)
            inorder(root->left);
        if(!head)
            head = root;
        root->left = prev;
        if(prev)
            prev->right = root;
        prev = root;
        if(root->right)
            inorder(root->right);
    }
    Node* treeToDoublyList(Node* root) {
        if(!root)
            return root;
        inorder(root);
        prev->right = head;
        head->left = prev;
        Node* p = head;
        return head;
    }
};

剑指 Offer 54. 二叉搜索树的第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 ans;
    void inorder(TreeNode* p, int &k)
    {
        if(p->right)
            inorder(p->right, k);
        if(k==1)
            ans = p->val;
        k--;
        if(p->left)
            inorder(p->left, k);
    }
    int kthLargest(TreeNode* root, int k) {
        if(root==NULL||k==0)
            return -1;
        inorder(root, k);
        return ans;
    }
};

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

对于求二叉搜索树的最近公共祖先，思路很简单：
根据二叉搜索树的性质有：
(1) 若p，q都大于root，则最近公共祖先应该在root的右子树找。
(2) 若p，q都小于root，则最近公共祖先应该在root的左子树找。
(3) 若p，q在root之间，则root就是最近公共组祖先了。

C++版

/**
 * 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==NULL)
            return NULL;
        int val = root->val;
        if((val>=p->val&&val<=q->val)||(val>=q->val&&val<=p->val))
            return root;
        else if(val>=p->val&&val>=q->val)
            return lowestCommonAncestor(root->left, p, q);
        else return lowestCommonAncestor(root->right, p, q);
    }
};

Java版

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) {
            return root;
        }
        if(root.val < Math.max(p.val, q.val) && root.val > Math.min(p.val, q.val)) {
            return root;
        }
        if(p.val > root.val && q.val > root.val) {
            return lowestCommonAncestor(root.right, p, q);
        }
        if(p.val < root.val && q.val < root.val) {
            return lowestCommonAncestor(root.left, p, q);
        }
        return root;
    }
}

剑指 Offer 68 - II. 二叉树的最近公共祖先

对于普通的二叉树来说，最近公共祖先的求法：
(1) 若左子树不含p，q节点，则“最近公共祖先”应该去右子树那儿找
(2) 若右子树不含p，q节点，则“最近公共祖先”应该去左子树那儿找
(3) 若p，q分别在左右子树中，则“最近公共祖先”就是root了。

C++版

/**
 * 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==NULL||root==p||root==q)
            return root;
        TreeNode* le = lowestCommonAncestor(root->left,p,q);
        TreeNode* ri = lowestCommonAncestor(root->right,p,q);
        if(le!=NULL&&ri!=NULL)
            return root;
        if(le==NULL)
            return ri;
        if(ri==NULL)
            return le;
        return NULL;
    }
};

Java版

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null) {
            return root;
        }
        if(root == p || root == q) {
            return root;
        }
        TreeNode findA = lowestCommonAncestor(root.left, p, q);
        TreeNode findB = lowestCommonAncestor(root.right, p, q);
        if(findA != null && findB != null) {
            return root;
        }
        if(findB == null) {
            return findA;
        }
        if(findA == null) {
            return findB;
        }
        return null;
    }
}
ChasingTheFreeWind
关注
专栏目录
剑指offer刷题
weixin_42145502的博客
11-21 141
2.双指针思想 替换空格 class Solution { public: string replaceSpace(string s) { int count=0; int oldsize=s.size(); for(int i=0;i<oldsize;i++){ if(s[i]==' '){ count++; } } ...
【剑指Offer】剑指Offer刷题笔记
passnight的博客
03-13 911
数组和字符串 剑指 Offer 04. 二维数组中的查找 在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 示例: 现有矩阵 matrix 如下： [ [1, 4, 7, 11, 15], [2, 5, 8, 12, 19], [3, 6, 9, 16, 22], [10, 13, 14, 17, 24], [18, 21, 23, 26, 30]
剑指Offer项目使用教程
最新发布
gitblog_00992的博客
08-16 267
剑指Offer项目使用教程 SwordOffer《剑指offer》Java版代码实现项目地址:https://gitcode.com/gh_mirrors/sw/SwordOffer 1. 项目的目录结构及介绍 SwordOffer/ ├── src/ │ ├── main/ │ │ ├── java/ │ │ │ ├── com/ │ │ │ │ ├──...
剑指Offer系列刷题笔记汇总
热门推荐
Jack-Cui
02-03 5万+
本文转自：个人网站：点击查看 一前言 二总结 链表-8道 二叉树12道 二叉搜索树3道 数组11道 字符串8道 栈3道 递归4道 回溯法2道 其他15道 一、前言 本系列文章为《剑指Offer》刷题笔记。 刷题平台：牛客网 书籍下载：共享资源 刷题刷的比较慢，花费了两个多月，终于将所有题目过了一遍，牛客网一共有66道题，这次刷题主要使用C++，接下来会使用Python...
剑指offer笔记（一）
faker1895的博客
06-05 260
第一章 面试的流程 面试官谈面试 对于初级程序员，一般会偏向考察算法和数据结构，看应聘者的基本功；对于高级程序员，会多关注专业技能和项目经验。 应聘者要事先做好准备，对公司近况、项目情况有所了解，对应聘的工作很有热情。另外，应聘者还要准备好合适的问题问面试官。 应聘者在面试过程中首先需要放松，不要过于紧张，这有助于后面解决问题时开拓思路。其次不要急于编写代码，应该先了解清楚所要解决的...
剑指Offer刷题笔记·
weixin_43823756的博客
11-19 186
题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 思路： 我们可以根据二维数组的特性，在查找数组里是否有这个整数时，我们可以按行和列去查找。 我们可以看到以上二维数组的存储则： 行数：int row = (int)array.length; 列数：int col = (int)array[0].length; 1.有了行和列，我们就得在数组中选取一个数去
剑指offer刷题笔记
11-08
### 剑指Offer刷题笔记知识点解析 #### 一、二维数组查找 **题目描述：** 给定一个二维数组，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。编写一个函数来判断一个给定的数是否存在...
剑指offer刷题笔记.zip
05-13
这个压缩包“剑指offer刷题笔记.zip”显然包含了作者对这些面试题的解题思路、算法分析以及相关知识点的详细笔记。以下是对这些知识点的详细阐述： 1. **数据结构与算法** - **数组**：在《剑指Offer》中，数组是...
剑指offer刷题笔记汇总
不忘初心~
08-22 522
剑指offer刷题笔记汇总
剑指offer总结-笔记
wuzhaoqing325的博客
03-27 246
1.unshift() push():在数组末尾添加元素 pop:删除数组末尾第一个元素，并返回这个元素 unshift:在数组开头添加元素 shift:删除数组开头的第一个元素，并返回这个元素 2.slice() arrayObject.slice(start,end) 返回从start到end(不包括end)的元素 ...
剑指Offer系列刷题笔记
qq_53183211的博客
10-27 318
剑指Offer系列刷题笔记汇总 文章目录剑指Offer系列刷题笔记汇总前言一、目录如下（持续更新） 前言 本系列为《剑指Offer》第二版全集 使用语言：Java 记录自己学习过程 从第一题开始 开始时间2021年10月27日21：00； 一、目录如下（持续更新） ...
剑指offer笔记
yooozy的博客
03-16 82
1. &gt;&gt; 表示算术右移，补符号位 &gt;&gt;&gt; 表示逻辑右移，补0
剑指Offer笔记
LOONG
09-05 177
剑指Offer笔记 二位数组中的查找 tag 查找 数组 题目描述 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 题解 规律：每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序 也即：右上角数字num大于本行，小于本列，将右上角数字与target比较，如果num > target 删除本列，num < target 删除本行，相等
"剑指Offer刷题：二维数组中查找问题解析
剑指offer是一本非常经典的面试书籍，其中的编程题目常常被用于各种面试中。而在剑指offer中的第一道题目就是关于在二维数组中查找某个整数的问题。 题目要求我们从一个二维数组中查找是否存在某个整数。这个二维...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值