C++ 版本 剑指offer

最新推荐文章于 2024-08-05 14:46:49 发布
最新推荐文章于 2024-08-05 14:46:49 发布
阅读量488 收藏
点赞数
分类专栏： 剑指offer C/ C++ 编程知识 文章标签： C++ 剑指offer 树结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40587575/article/details/101229346
版权

1. 二维数组的查找：

在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution {
public:
    bool Find(int target, vector<vector<int> > array) {
        // 从左下角开始计算
        if (array.empty()) return false;
        int rows = array.size();
        int cols = array[0].size();
        
        int col = 0;
        int row = rows -1;  // 此处记得要减去 1 
        while (col < cols && row >= 0){
            if (array[row][col] == target) return true;
            else if (array[row][col] > target){
                row --;
            }else{
                col ++;
            }

        }
        return false;
        
    }
};

2.替换空格

从后向前替换，先遍历一遍统计空格的数目，然后扩张字符串使得可以放下替换后的字符，然后从后向前依次复制，非空格字符直接复制，空格字符用题目要求的替换。

class Solution {
public:
	void replaceSpace(char *str,int length) {
        if (str == nullptr || length == 0) return ;
        int spaceCount = 0;
        // 计算空格的数量
        for (int i = 0; i< length; i++){
            if (str[i] == ' '){
                spaceCount += 1;
            }
        }
        if (spaceCount == 0){
            return ;
        }
        int new_length = length + 2 * spaceCount;
        int old_index = length - 1;
        int new_index = new_length -1;
        
        while (new_index > old_index && old_index >= 0){
            if (str[old_index] == ' '){
                str[new_index--] = '0';
                str[new_index--] ='2';
                str[new_index--] ='%';
                old_index --;

            }else{
                str[new_index--] = str[old_index--]; // 将old 的字符串分配给新的
            }
        }

	}
};

 

4.重建二叉树

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        if (pre.size() == 0 || vin.size() == 0) return NULL;
        vector<int> pre_left, tin_left;
        vector<int> pre_right, tin_right;
        
        // 前序第一个值作为根节点
        TreeNode* root = new TreeNode(pre[0]);
        // 找到第一个根节点，在tin 中的位置
        auto pos = find(vin.begin(), vin.end(), pre[0]);
        int index = pos - vin.begin();
        pre_left = vector<int> (pre.begin()+1, pre.begin() + index +1);
        tin_left = vector<int> (vin.begin(), vin.begin() + index);
        
        pre_right = vector<int> (pre.begin()+index+1, pre.end());
        tin_right = vector<int> (vin.begin() +index+1, vin.end());
        
        root->left = reConstructBinaryTree(pre_left, tin_left);
        root->right = reConstructBinaryTree(pre_right, tin_right);
        return root;
        
        
    }
};

 

树的子结构

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        if (pRoot1 == nullptr || pRoot2 == nullptr) return false;
        bool result = false;
        // 如果结点相同，则递归判断左右结点是否相同
        if (pRoot1->val == pRoot2->val){
            result = isSubTree(pRoot1, pRoot2);
        }
        
        // 如果结点不相同，则判断A 树的左子树，右子树
        if (result == false){
            result = HasSubtree(pRoot1->left, pRoot2);
        }
        if (result == false){
            result = HasSubtree(pRoot1->right, pRoot2);
        }
        return result;

    }
    
    bool isSubTree(TreeNode* pRoot1, TreeNode* pRoot2){
        if(pRoot2 == nullptr) return true;
        if (pRoot1 == nullptr) return false;
        bool sub1, sub2, sub3;
        sub1 = isSubTree(pRoot1->left, pRoot2->left);
        sub2 = isSubTree(pRoot1->right, pRoot2->right);
        sub3 = (pRoot1->val == pRoot2->val);
        return (sub1 && sub2 && sub3);
    }
};

二叉树的镜像

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    void Mirror(TreeNode *pRoot) {
        // 先交换左右2个结点，再交换2 个子树
        if (pRoot == nullptr || (pRoot->left == nullptr && pRoot->right == nullptr)){
            return;
        }
        TreeNode* temp = NULL;
        temp = pRoot->left;
        pRoot->left = pRoot->right;
        pRoot->right = temp;
        
        if (pRoot->left != nullptr){
            Mirror(pRoot->left);
        }
        if (pRoot->right != nullptr){
            Mirror(pRoot->right);
        }
        
        
    }
};

包含min函数的栈

#include <vector>
using namespace std;
class Solution {
private:
    vector<int> minstack;
    vector<int> stack;
public:
    void push(int value) {
        stack.push_back(value);
        if (minstack.size() == 0 || min() > value){
            minstack.push_back(value);
        }else{
            minstack.push_back(min());
        }
    }
    void pop() {
        stack.pop_back();
        minstack.pop_back();
    }
    int top() {
        return stack[stack.size()-1];
    }
    int min() {
        return minstack[minstack.size()-1];
    }
};

使用栈

class Solution {
private:
    stack<int> stack1, minstack;
public:
    void push(int value) {
        if (minstack.empty() || min() > value){
            minstack.push(value);
            stack1.push(value);
        }else{
            minstack.push(min());
            stack1.push(value);
        }
    }
    void pop() {
        stack1.pop();
        minstack.pop();
    }
    int top() {
        return stack1.top();
    }
    int min() {
        return minstack.top();
    }
};

栈的压入弹出序列

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if (pushV.size() == 0 || popV.size() == 0){
            return false;
        }
        vector<int> stack;
        for (int i =0; i < pushV.size(); i++){
            stack.push_back(pushV[i]);
            while (popV.size() != 0 && stack[stack.size()-1] == popV[0]){
                stack.pop_back();
                popV.erase(popV.begin());
            }
        }
        if (stack.size() == 0){
            return true;
        }else{
            return false;
        }
    }
};

从上往下打印二叉树

使用队列

/*
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> res;
        if (root == nullptr){
            return res;
        }
        queue<TreeNode*> q;
        q.push(root);
        while (!q.empty()){
            res.push_back(q.front()->val);  // 将队列中首个元素放在res中
            if (q.front() -> left != nullptr){
                q.push(q.front() -> left);
            }
            if (q.front() -> right != nullptr){
                q.push(q.front() -> right);
            }
            q.pop();  // 将首个元素删除
        }
        return res;

    }
};

二叉树的深度

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
    int TreeDepth(TreeNode* pRoot)
    {
        if (pRoot == nullptr) return 0;
        if (pRoot->left == nullptr && pRoot->right == nullptr){
            return 1;
        }
        int len = max(TreeDepth(pRoot->left), TreeDepth(pRoot->right));
        return len +1;
                      
    
    }
};

平衡二叉树

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {
        if (pRoot == nullptr){
            return true;
        }
        int ld = getDepth(pRoot->left);
        int rd = getDepth(pRoot->right);
        if (abs(ld - rd) > 1){  // 如果左右子树深度大于1，则不是
            return false;
        }
        bool pleft, pright;
        pleft = IsBalanced_Solution(pRoot->left); // 递归判断左右子树
        pright  = IsBalanced_Solution(pRoot->right);
        return (pleft && pright);

    }
    
    int getDepth(TreeNode* pRoot){  // 获取树的深度
        if (pRoot == nullptr){
            return 0;
        }
        int leftDepth, rightDepth;
        leftDepth = getDepth(pRoot->left);
        rightDepth = getDepth(pRoot->right);
        return 1 + max(leftDepth, rightDepth);
    }
};

第一次只出现一次的字符

使用map

class Solution {
public:
    int FirstNotRepeatingChar(string str) {
        map<char, int> mp;
        for (int i = 0;i < str.size(); i++){
            mp[str[i]] ++;
        }
        for (int i = 0; i< str.size(); i++){
            if (mp[str[i]] == 1){
                return i;
            }
        }
        return -1;
    }
};

 数组出现次数超过一半的数字

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
        map<int, int> mp;
        int halfLen = numbers.size() / 2;
        for (int i =0 ; i < numbers.size(); i++){
            mp[numbers[i]] ++;
        }
        for (int i = 0; i< numbers.size(); i++){
            if (mp[numbers[i]] > halfLen){
                return numbers[i];
            }
        }
        return 0;
    }
};

二叉树的和为某一值的路径

/*
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> > res;
    vector<int> path;
    void find(TreeNode* root, int sum){  
        if (!root) return;
        path.push_back(root->val);
        if (root->left == nullptr && root->right == nullptr && sum == root->val){
            res.push_back(path);  // 如果左右子树不在，且 最后的sum值就是结点值，则代表找到路径
        }else{
            if (root->left){
                find(root->left, sum-root->val);
            }
            if (root->right){
                find(root->right, sum - root->val);
            }
            
        }
        path.pop_back(); // 回溯查找
    }
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        find(root, expectNumber);
        return res;

    }
};

二叉树中序的下一个结点（有父节点）

1， 如果存在右子树，一直找到左节点； 2.如果不存在，则往上找到父节点

/*
struct TreeLinkNode {
    int val;
    struct TreeLinkNode *left;
    struct TreeLinkNode *right;
    struct TreeLinkNode *next;
    TreeLinkNode(int x) :val(x), left(NULL), right(NULL), next(NULL) {
        
    }
};
*/
class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        // 1， 如果存在右子树，一直找到左节点； 2.如果不存在，则往上找到父节点
        if (pNode->right){
            pNode = pNode->right;
            while (pNode->left){
                pNode = pNode->left;  // 一直找到左结点
            }
            return pNode;
        }
        while (pNode->next){  // 如果存在父亲节点
            TreeLinkNode* pRoot = pNode->next;
            if (pRoot->left == pNode) return pRoot;
            pNode = pNode->next;
        }
        return NULL;
    }
};

判断是否是对称二叉树

借助辅助函数：判断1.结点值是否相同，2.左子树的右结点 与 右子树左节点是否相同 3.  左子树的左结点 与 右子树右节点是否相同

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
public:
    bool isSymmetrical(TreeNode* pRoot)
    {
        if (!pRoot || (!pRoot->left && !pRoot->right)) return true;  // 如果只有0，或1 个结点
        return helper(pRoot->left, pRoot->right);
    
    }
    bool helper(TreeNode* left, TreeNode* right){
        if (!left && !right) return true;
        if (!left || !right) return false;
        bool left_judge = helper(left->left, right->right);
        bool right_judge = helper(left->right, right->left);
        bool isBan = (left->val == right ->val);
        return (left_judge && right_judge && isBan);
    }

};

按之字形打印二叉树

/*
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> > Print(TreeNode* pRoot) {
        // 使用队列， 和一个bool类型，是偶数时则翻转
        vector<vector<int>> res;
        if (!pRoot) return res;
        queue<TreeNode*> q;
        bool rev = false;
        q.push(pRoot);
        while (!q.empty()){
            vector<int> vec;
            int size = q.size();
            for (int i =0; i < size; i++){

                TreeNode* node = q.front();
                q.pop();
                vec.push_back(node->val);
                if (node->left) q.push(node->left);
                if (node->right) q.push(node->right);
            }
            if (rev){
                std::reverse(vec.begin(), vec.end());
            }
            res.push_back(vec);
            rev = !rev;  // 在 true 和 false 之间转换
        }
        return res;
    }
    
};

把二叉树打印成多行

使用队列的方法：

/*
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> > Print(TreeNode* pRoot) {
            vector<vector<int> > res;
            if (!pRoot) return res;
            queue<TreeNode*> q;
            q.push(pRoot);
            
            while (!q.empty()){
                vector<int> vec;
                int size = q.size();
                for (int i=0; i< size; i++){
                    TreeNode* node = q.front();
                    q.pop();
                    vec.push_back(node->val);
                    if (node->left) q.push(node->left);
                    if (node->right) q.push(node->right);
                }
                res.push_back(vec);
            }
            return res;
            
        
        }
    
};

序列二叉树

 

二叉搜索树的后序遍历顺序

 

二叉树和双向链表

 

二叉搜索树的第k个结点

通过中序遍历获取结点值

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};
*/
class Solution {
private:
    int count = 0;
public:
    TreeNode* KthNode(TreeNode* pRoot, int k)
    {
        if (pRoot){
            // 中序遍历结点值， 根 左 右
            TreeNode* ret = KthNode(pRoot->left, k);
            if (ret){
                return ret;
            }
            if (++count == k) return pRoot;
            ret = KthNode(pRoot->right, k);
            if (ret){
                return ret;
            }
        }
        return nullptr;
        
    }

    
};

 

 

 

蜘蛛侠不会飞
关注
专栏目录
剑指offer——C++
jianchibuxie0的博客
10-15 282
剑指3 classSolution{ public: intfindRepeatNumber(vector<int>&nums){ intlength=nums.size(); if(length<=0){ return-1; } for(inti=0;i<length;++i){ if(nums[i]<0||nums[i]>...
剑指offer（C++）1
08-04
剑指offer（C++）1 在该资源中，我们将深入探讨剑指offer（C++）1中涉及的知识点，包括数组、vector、循环、条件语句、交换算法、函数返回值等。 数组 在这份代码中，我们可以看到数组的使用。数组是一种基本的...
剑指offer（C++版本）
qq_28609735的博客
12-12 399
转载自：https://blog.csdn.net/u012477435/article/details/83351659
《剑指offer》题目 C++详细题解
qq_64446981的博客
08-05 656
这个过程，会让[left，right]区间缩小，这个过程中，left永远在原数组前半部分，right永远在原数组的后半部分，而范围会一直缩小，当left和right相邻时，left指向的位置，就是最小元素的位置，但是，因为题目说的是非递减，也就意味着数据允许重复，因为有重复值，就可能会有a[left] == a[mid] ==a[right]的情况，此时我们就不能用单纯的二分算法模板来写这个题目，我们此时需要单独处理一下有重复值的情况，我们上面是采用的右端点进行判断，同时我们也可以使用左端点进行判断。
剑指offe【31-67】
weixin_43878297的博客
08-31 723
文章目录31、整数中1出现的次数32、把数组排成最小的数33、丑数34、第一个只出现一次的字符 31、整数中1出现的次数 求出1 ~ 13的整数中1出现的次数,并算出100~ 1300的整数中1出现的次数？为此他特别数了一下1~13中包含1的数字有1、10、11、12、13因此共出现6次,但是对于后面问题他就没辙了。ACMer希望你们帮帮他,并把问题更加普遍化,可以很快的求出任意非负整数区间中1出现的次数（从1 到 n 中1出现的次数）。 思路： public class Solution {
【C++】【剑指offer】
勿于浮沙筑高台
08-08 895
1、sizeof的概念 定义一个空的类型，里面没有任何数据成员和变量，对该类型求sizeof得到的结果是什么？ 看具体的编译，空类型占用对少个size 1、1为什么不是0？ 我们申明该类型的实例，或者说对象的时候，本身就要占一定内存空间，否则无法使用这些实例，具体占用的字节就是编译器决定的。在vs中空类型占1个字节。 1、2如果在该类型中添加构造函数和析构函数 也是一样 调用构造函数...
剑指offer第二版-源代码（C++）
04-09
根据书上思路和自己的理解，整理出的尽可能精简的代码。全部66题已通过测试，并附有详细注释。
c++-剑指offer题解之丑数
最新发布
08-10
c++ c++_剑指offer题解之丑数
c++-剑指offer题解之矩形覆盖
08-10
c++ c++_剑指offer题解之矩形覆盖
c++-剑指offer题解之斐波那契数列
08-09
c++ c++_剑指offer题解之斐波那契数列
剑指offer刷题集锦（C++版本）
weixin_40586929的博客
03-23 282
1.在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 class Solution { public: bool Find(int target, vector<vector<int> > array) { ...
剑指offer c++版本
caijixiaodiao的博客
04-26 1105
文章目录前言用两个栈实现队列包含min函数的栈 前言 用来记录自己刷剑指offer c++版本的过程，也可以简单的作为题解发布供大家参考交流~要是哪里有错误或者大家有更好的方法可以指出哦！ < 本文为实时更新 > 用两个栈实现队列 题目描述：用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 ) 思路：将一个栈A作为入队的容器，
剑指Offer题目汇总(C++版)
Yummy
04-11 2493
最近，鉴于目前网上关于《剑指Offer》C++版的汇总资料特别少或者不规范，特整理了一版书中重要的考题，以备学习使用。 目录 一、位运算 1. 二进制中1的个数 2. 二进制中0的个数 3. 二进制高位连续0的个数 二、二叉树 1. 二叉搜索树第k个结点 2. 从上往下打印二叉树 3. 二叉树打印成多行 4. 数据流中位数 5. 二叉树中和为某一值的路径 6. 重建二叉树 ...
剑指offer题解(C++版)
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
09-23 2386
剑指offer习题题解，C++版本代码，并附带个人算法题解题方法总结。题目包括数据结构：数组、链表、栈和队列等，以及常见的算法：排序、分治、回溯、递归、贪心、动态规划等。
[leetcode]剑指offer(C++版题解)
qq_52608074的博客
04-12 2568
剑指offer第一天剑指 Offer 09. 用两个栈实现队列剑指 Offer 30. 包含min函数的栈有待更新。。。。 第一天 剑指 Offer 09. 用两个栈实现队列 ->点这里进入leetcode 这道题的意思就是让我们使用两个栈实现一个队列， 简单复习一下： 栈：先进后出（栈顶进出元素） 队列：先进先出（队列头出元素，队列尾进元素） 我们会发现栈可以做到队列尾进元素，但是如何让栈底出元素是一个问题 我们会想到将一个栈的元素依次出栈放到另外一个栈中的时候，他的元素是不是会倒过来，例如：
剑指offer c++
酸乳乳酸的博客
12-22 302
3.从你头到尾打印链表 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution { public: ...
剑指offer (c++版)
boshuzhang的专栏
07-15 1616
https://blog.csdn.net/u012477435/article/details/83351659#_1992
剑指Offer：算法题解与代码
这篇资源是关于《剑指Offer》这本书中的算法题目的编程实现，主要语言是C++，涉及的标签包括算法和C++。作者使用Markdown格式编写了文档，使得排版清晰，便于阅读。文件中包含的具体题目有二维数组的查找和数组中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值