剑指offer（三）

最新推荐文章于 2024-03-19 10:30:28 发布
最新推荐文章于 2024-03-19 10:30:28 发布
阅读量193 收藏
点赞数
分类专栏： # 【02】刷题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxt_1/article/details/93336235
版权

文章目录

21. 栈的压入、弹出序列

在这里插入图片描述

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        
        int i = 0;
        int j = 0;
        
        for(; i<pushV.size(); i++)
        {
            s.push(pushV[i]);
            while(j < popV.size() && s.top() == popV[j])
            {
                s.pop();
                j++;
            }
        }
        
        return s.empty();        
    }
    
private:
    stack<int> s;
};

22. 从上往下打印二叉树

在这里插入图片描述

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        
        vector<int> ret;
        if(!root)
            return ret;
        
        queue<TreeNode*> q;
        q.push(root);
        
        while(!q.empty())
        {
            TreeNode *node = q.front();
            q.pop();
            ret.push_back(node->val);
            
            if(node->left)
                q.push(node->left);
            if(node->right)
                q.push(node->right);
        }
        
        return ret;
    }
};

23. 二叉搜索树的后序遍历序列

在这里插入图片描述

二叉搜索树（二叉排序树）：

  • 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值
class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {

        if(sequence.size() == 0)
            return false;
        
        return help(sequence, 0, sequence.size()-1);
    }
    
private:
    bool help(const vector<int>& sequence, int l, int r)
    {
        if(l >= r)
            return true;
        
        int target = sequence[r];                //根节点值
        int i = l;
        while(sequence[i] < target && i < r)     //左子树 < 根节点值
            i++;
        
        int mid = i-1;
        for(; i< r; i++)
        {
            if(sequence[i] <= target)
                return false;
        }
        
        return help(sequence, l, mid) && help(sequence, mid+1, r-1);
    }
};

24.二叉树中和为某一值的路径

在这里插入图片描述

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {

        vector<vector<int>> ret;
        if(!root)
            return ret;
        
        vector<int> v;
        help(root, expectNumber, ret, v);
        
        return ret;
    }
    
private:
    void help(TreeNode *node, int expectNumber, vector<vector<int>> &ret, vector<int> &v)
    {
        
        v.push_back(node->val);
        
        if(!node->left && !node->right && node->val == expectNumber)
        {
            ret.push_back(v);
        }
       
        
        if(node->left)
        {
            help(node->left, expectNumber-node->val, ret, v);
        }
        
        if(node->right)
        {
            help(node->right, expectNumber-node->val, ret, v);
        }
        
        v.pop_back();
    }
};

25. 复杂链表的复制

在这里插入图片描述

方法一：

  • 第一遍构建next指针，同时保存random信息到 map<RandomListNode , RandomListNode >
  • 第二遍根据 map 信息构建random
/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)
            return pHead;
        
        RandomListNode *newHead = new RandomListNode(pHead->label);
        m[pHead] = newHead;
        
        RandomListNode *curP = pHead->next;
        RandomListNode *curN = newHead;
        while(curP)
        {
            RandomListNode *node = new RandomListNode(curP->label);
            curN->next = node;
            
            m[curP] = node;
            
            curP = curP->next;
            curN = curN->next;
        }
        
        curP = pHead;
        curN = newHead;
        while(curP)
        {
            if(curP->random)
            {
                RandomListNode *tmp = curP->random;
                curN->random = m[tmp];
            }
            
            curP = curP->next;
            curN = curN->next;
        }
        
        return newHead;
    }
    
private:
    map<RandomListNode*, RandomListNode*> m;		//first：保存原始链表节点	second：保存对应的新链表节点
};

方法二：

  • 将每个新建的节点放在对应原节点之后
  • 原节点的random的next为新节点的random
  • 分离两个链表
/*
struct RandomListNode {
    int label;
    struct RandomListNode *next, *random;
    RandomListNode(int x) :
            label(x), next(NULL), random(NULL) {
    }
};
*/
class Solution {
public:
    RandomListNode* Clone(RandomListNode* pHead)
    {
        if(!pHead)
            return pHead;
        
        RandomListNode *cur = pHead;
        while(cur)                            //构建 next
        {
            RandomListNode *node = new RandomListNode(cur->label);
            node->next = cur->next;
            cur->next = node;
            
            cur = node->next;
        }
        
        cur = pHead;
        while(cur)                            //构建 random
        {
            RandomListNode *node = cur->next;
            if(cur->random)
            {
                node->random = cur->random->next;
            }
            
            cur = node->next;
        }
        
        cur = pHead;
        RandomListNode *ret = cur->next;
        while(cur->next)                    //分离链表  务必画图
        {
            RandomListNode *newN = cur->next;
            cur->next = cur->next->next;
            cur = newN;
        }
        
        return ret;
    }

};

26. 二叉搜索树与双向链表

在这里插入图片描述

方法一：

  • 中序遍历，将节点保存在 vector 中
  • 遍历vector，将节点的 left 指向前一个节点，right 指向后一个节点
/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/

class Solution
{
public:
    
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if((pRootOfTree == NULL) || (!pRootOfTree->left) && (!pRootOfTree->right))
            return pRootOfTree;
        inOrder(pRootOfTree);
        nodeVector[0]->left = NULL;
        nodeVector[0]->right = nodeVector[1];
        int i = 1;
        for( ; i < nodeVector.size() - 1; i ++)
        {
            nodeVector[i]->left = nodeVector[i - 1];
            nodeVector[i]->right = nodeVector[i + 1];
        }
        nodeVector[i]->left = nodeVector[i - 1];
        nodeVector[i]->right = NULL;
        return nodeVector[0];
    }
    
private:
    vector<TreeNode *> nodeVector;

    void inOrder(TreeNode* root)
    {
        if(root->left)
            inOrder(root->left);
        nodeVector.push_back(root);
        if(root->right)
            inOrder(root->right);
    }
};

方法二：

  • 将左子树变为有序的排序链表，
  • 再将右子树变为有序的链表，
  • 然后将当前结点插入到两个链表中间
/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/

class Solution
{
public:
    
    TreeNode* Convert(TreeNode* pRootOfTree)
    {
        if(!pRootOfTree)
            return pRootOfTree;
        
        TreeNode *lNode = Convert(pRootOfTree->left);
        TreeNode *rNode = Convert(pRootOfTree->right);
        
        TreeNode *node = lNode;
        if(node)
        {
            while(node->right)                //找到左链表的最后一个节点
                node = node->right;
            
            node->right = pRootOfTree;
        }
        pRootOfTree->left = node;
        
        if(rNode)
            rNode->left = pRootOfTree;
        pRootOfTree->right = rNode;
        
        return (lNode)?lNode:pRootOfTree;
    }

};

27. 字符串的排列

在这里插入图片描述

class Solution {
public:
    vector<string> Permutation(string str) {       
        
        if(str.length() == 0)
            return vector<string>();
        
        visited = vector<bool>(str.length(), false);
        
        string s;
        help(str, 0, s);
        
        vector<string> v(s_.begin(), s_.end());
        return v;
    }
    
private:
    set<string> s_;            //去重
    vector<bool> visited;
    
    void help(const string &str, int index, string s)
    {
        if(index == str.length())
        {
            s_.insert(s);
            return ;
        }
        
        for(int i=0; i<str.length(); i++)
        {
            if(!visited[i])
            {
                visited[i] = true;
                help(str, index+1, s+str[i]);
                visited[i] = false;
            }
        }
    }
};

28. 数组中出现次数超过一半的数字

在这里插入图片描述

方法一：

  • 用map统计数字出现的次数
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
    
        for(int i=0; i<numbers.size(); i++)
        {
            int num = ++m[numbers[i]];
            if(num > numbers.size()/2)
                return numbers[i];
        }
        
        return 0;
    }
    
private:
    map<int, int> m;
};

方法二：

  • 数组排序后，如果符合条件的数存在，则一定是数组中间那个数
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
    
        sort(numbers.begin(), numbers.end());
        
        int n = numbers.size();
        int mid = numbers[n/2];
        int ret = 0;
        for(int i=0; i<n; i++)
        {
            if(numbers[i] == mid)
                ret++;
        }
        
        
        return (ret>n/2)?mid:0;
    }
 
};

方法三：

  • 如果符合条件的数存在，则其他数字出现的次数和要小于这个数
class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
    
        int num = numbers[0];
        int index = 1;
        
        for(int i=1; i<numbers.size(); i++)
        {
            if(index == 0)
            {
                num = numbers[i];
                index = 1;
                continue;
            }
            
            if(num == numbers[i])
                index++;
            else
                index--;
            
        }
        
        //判断是否符合条件
        int count = 0;
        for(int i=0; i<numbers.size(); i++)
        {
            if(numbers[i] == num)
                count++;
        }
        
        return (count>numbers.size()/2)?num:0;
    }
 
};

29. 最小的K个数

在这里插入图片描述

方法一：

  • 大根堆
class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        
        vector<int> ret;
        if(input.size() < k)
            return ret;
        
        for(int i=0; i<input.size(); i++)
        {
            if(pq.size()<=k || pq.top() > input[i])
                pq.push(input[i]);
            
            if(pq.size() > k)
                pq.pop();
        }
        
        while(pq.size() > 0)
        {
            ret.push_back(pq.top());
            pq.pop();
        }
       
        return ret;
    }
    
private:
    priority_queue<int> pq;
};

方法二：

  • 排序

30. 连续子数组的最大和

在这里插入图片描述

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
    
        int maxSum = INT_MIN;
        int sum = 0;
        for(int i=0; i<array.size(); i++)
        {
            sum += array[i];
            if(sum > maxSum)
                maxSum = sum;
            if(sum < 0)            //在每次元素累加和小于0时，从下一个元素重新开始累加
                sum = 0;
        }
        
        return maxSum;
    }
};

动态规划

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
    
        memo = vector<int>(array.size(), -1);
        memo[0] = array[0];
         
        for(int i=1; i<array.size(); i++)
        {
            memo[i] = max(memo[i-1]+array[i], array[i]);
        }
        
        sort(memo.begin(), memo.end());
        return memo[array.size()-1];
    }
    
private:
    vector<int> memo;    //memo[i]：以array[i]结尾的子数组最大和
};
神秘的火柴人
关注
专栏目录
《剑指offer》题目汇总
李滚滚的博客
03-28 1772
文章目录面试题1 赋值运算符函数以上是基本的内容，但还是有代码异常安全性问题存在。 面试题1 赋值运算符函数 题目：如下为类型CMyString的声明，请为该类型添加赋值运算符函数。 class CMyString { public: CMyString(char* pData = nullptr); CMyString(const CMyString& str); ~CMyStri...
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
链表操作（04）
Jeffxu_lib的博客
08-27 228
题目01 【 输入一个链表，按链表从尾到头的顺序返回一个ArrayList 】 方法一：使用栈来作为中间保存结构 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { *...
数据结构实验一 线性表、堆栈和队列的操作与实现
GHY
01-29 3191
一、实验目的： 1、 领会单链表存储结构和掌握单链表中的各种基本运算算法设计； 2、 领会栈链存储结构和掌握栈链中的各种基本运算算法设计； 3、 领会环形队列存储结构和掌握环形队列中的各种基本运算算法设计； 4、 深入掌握单链表应用的算法设计； 5、 掌握栈应用的算法设计； 二、使用仪器、器材 微机一台 操作系统：WinXP 编程软件：C/C++编程软件 三、实验内容及原理 填入自己的内容（思路或算法流程图、源代码、说明等） 1、教材P74实验题2：实现单链表的各种基本运算的算法 编写一个程序linklis
剑指offer刷题
lhj_sjtu的博客
08-01 460
自己写的剑指offer答案，已经在牛客网上验证通过 我的github仓库:https://github.com/huijuanl/JianzhiOffer 牛客网剑指offer刷题网址:https://www.nowcoder.com/ta/coding-interviews...
剑指offer力扣题集
艺术的博客
03-19 592
剑指offer
剑指offer题目大全
大树叶 技术专栏
10-06 2387
　剑指Offer这本书已经学习完了，从中也学习到了不少的东西，现在做一个总的目录，供自已和大家一起参考，学如逆水行舟，不进则退。只有不断地学习才能跟上时候，跟得上技术的潮流！ 所有代码下载【https://github.com/Wang-Jun-Chao/coding-interviews】 目录 第01-10题   【剑指Offer学习】【面试题02：实现Singleton 模式——七...
《剑指offer》总纲目录[C++]
贫道绝缘子的博客
07-29 1154
按照第2版《剑指offer》顺序 第1~10题 《剑指offer》01--赋值运算符函数[C++] 《剑指offer》02--实现Singleton模式[C++] 《剑指offer》03--数组中重复的数字[C++] 《剑指offer》04--二维数组中的查找[C++] 《剑指offer》05--替换空格[C++] 《剑指offer》06--从尾到头打印链表[C++] 《剑指off...
剑指Offer题集（力扣）
热门推荐
qq_42958831的博客
05-07 1万+
力扣题单：https://leetcode.cn/problemset/all/?listId=lcof&page=1
《剑指 Offer》题解
kashine的博客
02-04 448
（简单）
剑指offer 61. 扑克牌中的顺子
kku101xyz的博客
04-18 801
Corux原创
剑指offer（C++）1
08-04
剑指offer（C++）1 在该资源中，我们将深入探讨剑指offer（C++）1中涉及的知识点，包括数组、vector、循环、条件语句、交换算法、函数返回值等。 数组 在这份代码中，我们可以看到数组的使用。数组是一种基本的...
剑指前端offerPDF版.pdf
03-18
#### 三、DOM操作技巧 - **获取元素位置**： - `elem.getBoundingClientRect()`可以返回元素的大小及其相对于视口的位置。 - 推荐使用`elem.getBoundingClientRect().width`、`elem.getBoundingClientRect()....
剑指offer-Java代码_java_剑指offer_
09-30
《剑指Offer》是一本备受推崇的编程面试指南，尤其对于Java开发者来说，它提供了大量精心设计的面试题目，旨在帮助求职者提升编程技能和解决问题的能力。这本书的Java代码实现和文字说明是深入理解问题解决方案的...
为Matlab 用户提供丰富功能的工具集
11-03
Matlab 用户提供丰富功能的工具集。 从优点来看，其涵盖了诸多实用的功能模块。例如在计算机视觉和图像处理领域，可能包含了图像特征提取、目标检测、图像分割等常用算法的实现，这为相关领域的研究人员和开发者节省了大量的时间和精力，无需从头编写复杂的算法代码，提高了开发效率。工具包的文档相对较为详细，能够帮助用户快速上手并理解各个函数和工具的使用方法，降低了使用门槛。同时，它可能具有较好的兼容性，能够与 Matlab 的原生功能和其他常用工具箱协同工作，方便用户整合到自己的项目中。 1、资源项目源码均已通过严格测试验证，保证能够正常运行； 2、项目问题、技术讨论，可以给博主私信或留言，博主看到后会第一时间与您进行沟通； 3、本项目比较适合计算机领域相关的毕业设计课题、课程作业等使用，尤其对于人工智能、计算机科学与技术等相关专业，更为适合； 4、下载使用后，可先查看README.md文件（如有），本项目仅用作交流学习参考，请切勿用于商业用途。
技术资料分享KXTE9-2050 Specifications Rev 3非常好的技术资料.zip
11-03
技术资料分享KXTE9-2050 Specifications Rev 3非常好的技术资料.zip
yolo算法-废物数据集-1000张图像带标签-金属废料-杯子-垃圾桶-废物-纸张-塑料-瓶-有机废物.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
VB程序实例-使用Stream读写存储的图像.zip
最新发布
11-03
VB程序实例-使用Stream读写存储的图像.zip
剑指Offer：算法题解与代码
"剑指offer.md" 这篇资源是关于《剑指Offer》这本书中的算法题目的编程实现，主要语言是C++，涉及的标签包括算法和C++。作者使用Markdown格式编写了文档，使得排版清晰，便于阅读。文件中包含的具体题目有二维数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值