《剑指Offer》做题总结(二)

最新推荐文章于 2023-05-07 22:52:08 发布
最新推荐文章于 2023-05-07 22:52:08 发布
阅读量300 收藏 1
点赞数
分类专栏： 找工作 C/C++ 文章标签： 剑指Offer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011268787/article/details/77434455
版权

黑色加粗部分基本就是题目给出的部分，红色部分是自己需要注意的知识点。

16.合并两个排序的链表

题目描述：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

思路：

基本思想就是递归，首先想到最终返回的要么是p1的头，要么是p2的头，所以呢，可以用这个作为终止条件。

代码：

/*
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) :
val(x), next(NULL) {
}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1==NULL)
            return pHead2;
        else if(pHead2==NULL)
            return pHead1;
        
        ListNode* newhead=NULL;
        
        if(pHead1->val<pHead2->val)
            {
            
            newhead=pHead1;
            newhead->next=Merge(pHead1->next,pHead2);
            
        }else{
            newhead=pHead2;
            newhead->next=Merge(pHead1,pHead2->next);
            
        }
        return newhead;
    }
};


17.树的子结构

题目描述：

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

思路：

这一道题在这篇博客上讲的比较清楚：点击打开链接。主要思想就是先判断A，B是否有相同的根节点。其次是判断A的子节点是否和B的子结构。

代码：

/*
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* pRootA, TreeNode* pRootB)
    {
if(pRootA==NULL||pRootB==NULL)
            return false;
        return isSubtree(pRootA,pRootB) || HasSubtree(pRootA->left,pRootB) || HasSubtree(pRootA->right,pRootB);
        
        
    }
private:
    bool isSubtree(TreeNode* pRootA,TreeNode* pRootB){
        if(pRootB==NULL) return true;
        if(pRootA==NULL) return false;
        if(pRootA->val==pRootB->val)
            {
            return isSubtree(pRootA->left,pRootB->left)&& isSubtree(pRootA->right,pRootB->right);
            
        }else
            return false;
        
    }
};


18.二叉树的镜像

题目描述：

操作给定的二叉树，将其变换为源二叉树的镜像。

思路：

这道题的思路就是用递归,算是比较考验人的。

代码：

/*
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) {

            if(pRoot)
                {
                swap(pRoot->right,pRoot->left);
                Mirror(pRoot->right);
                Mirror(pRoot->left);
            }
       
    }

};

19.顺时针打印矩阵

题目描述：

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

思路：

这道题的思路就是上下左右四个边界，然后这四个边界用来作为记录遍历的条件。当然要注意其中遍历的判断条件避免二次遍历。

代码：

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
vector<int>res;
        int top,bottom,left,right;
        int row=matrix.size();
        int col=matrix[0].size();
        if(row==0||col==0)return res;
        top=0;bottom=row-1;
        left=0;right=col-1;
        while(left<=right && top<=bottom)
        {
        for(int i=left;i<=right;++i) res.push_back(matrix[top][i]);
                for(int i=top+1;i<=bottom;++i) res.push_back(matrix[i][right]);
                if(top!=bottom)
                for(int i=right-1;i>=left;--i) res.push_back(matrix[bottom][i]);
                if(left!=right)
                for(int i=bottom-1;i>top;i--) res.push_back(matrix[i][left]);
                left++,top++,right--,bottom--;
                
            }
            return res;
    }
        
};

20.包含min函数的栈

题目描述：

定义栈的数据结构，请在该类型中实现一个能够得到栈最小元素的min函数。

思路：

基本上是stack类型的应用吧。然后多引入了一个mindata的最小函数需要判断push进来的值是否比原来的top小

代码：

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


21.栈的压入、弹出序列

题目描述：

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4，5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

思路：

这道题没怎么理解，主要应该就是如果压入栈的最后的数和弹出栈一样就把最后的数单出。

代码：

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.size()==0) return false;
        vector<int> stack;
        for(int i=0,j=0;i<pushV.size();)
            {
            stack.push_back(pushV[i++]);
            while(j<popV.size() && stack.back()==popV[j])
                {
                stack.pop_back();
                j++
                
            }
            
        }
        return stack.empty();
    }
};

22.从上往下打印二叉树

题目描述：

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

思路：

这道题是典型的广度优先搜索的题目，有句话说的好：道理我都懂，但就是做不到。其实这一题拿到手我也是一头雾水。后来想明白了，说白了其实就是运用队列来实现，为什么用队列实现好呢？队列的特性摆在那儿，先进先出。而且使用方法和stack差不多，就是数据进出的顺序不一样罢了。

代码：


/*
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) {
//这不是典型的广度优先搜索bfs
      queue<TreeNode*>jinchen;
        vector<int>jieguo;
        TreeNode* yingru;
        if(root==NULL) return jieguo;
        jinchen.push(root);
        while(!jinchen.empty())
            {
            yingru=jinchen.front();
            jieguo.push_back(yingru->val);
            if(yingru->left!=NULL)
                jinchen.push(yingru->left);
            if(yingru->right!=NULL)
                jinchen.push(yingru->right);
            jinchen.pop();
            
            
        }
        return jieguo;
    }
};

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

题目描述：

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

思路：

这道题目呢，有个问题就是二叉搜索树的问题（毕竟不是科班出身，知识还是有所欠缺的），这个博客给出了比较详细的二叉树和二叉搜索树的区别：点击打开链接 。就是左孩子小于右孩子。还有一个就是这道题普遍采用是递归，但是采用这种写法显然优于递归写法。

代码：

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
//后序遍历，就是左右根的遍历顺序，判断一个序列是不是后序遍历的结果
        int size=sequence.size();
        if(0==size) return false;
        int i=0;
        while(--size)
            {
            while(sequence[i++]<sequence[size]);
            while(sequence[i++]>sequence[size]);
            
            if(i<size) return false;
            i=0;
            
        }
        return true;
    }
};

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>>buffer;
        vector<int>temp;
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
//这个应该是采用深度优先搜索，先全左然后再向右分
        //最后实现找到数字的目的。
        if(root==NULL)
            return buffer;
        temp.push_back(root->val);
        if((expectNumber-root->val)==0 && (root->left==NULL) && (root->right==NULL) )
            {
            buffer.push_back(temp);
        }
        FindPath(root->left,expectNumber-root->val);
        FindPath(root->right,expectNumber-root->val);
        if(temp.size()!=0)
            temp.pop_back();
        return buffer; 
    }
};

25.复杂链表的复制

题目描述：

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）

思路：

这一题还是比较难的，但是总的来说就是链表的运用，说到底还是自己比较渣 ，学的不好。

代码：

/*
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 NULL;
        nodeClone(pHead);
        connectRandom(pHead);
        return reconnect(pHead);  
    }
//[1]复制结点，插入到原结点后方
    void nodeClone(RandomListNode* head)
        {
        RanomListNode* pNode=head;
        while(pNode!=NULL)
            {
            RandomListNode* pClone=new RandomListNode(pNode->label);
            pClone->next=pNode->next;
            pNode->next=pClone;
            pNode=pClone->next;
        }
        
    }
    //还原新节点的random指针
    void connectRandom(RandomListNode* head)
{
        RandomListNode* pNode=head;
        while(pNode!=NULL){
            RandomListNode* pClone=pNode->next;
            if(pNode->random)
                {
                pClone->random=pNode->random->next;
                
            }
            pNode=pClone->next;
        }
    }
    //拆分
    RandomListNode * reconnect(RandomListNode * head){
        RandomListNode* pNode=head;
        RandomListNode* result=head->next;
        while(pNode!=NULL){
RandomListNode *pClone=pNode->next;
            pNode->next=pClone->next;
            pNode=pNode->next;
            if(pNode!=NULL)
                pClone->next=pNode->next;
        }
        return result;
    }

};

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

题目描述：

输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。

思路：

这一题还是比较难的。但是看了这幅图之后就比较清晰了，该如何去做。


在二叉树中，每个结点都有两个指向子结点的指针。在双向链表中，每个结点也有两个指针，它们分别指向前一个结点和后一个结点。由于这两种结点的结构相似，同时二叉搜索树也是一种排序的数据结构，因此在理论上有可能实现二叉搜索树和排序的双向链表的转换。在搜索二叉树中，左子结点的值总是小于父结点的值，右子结点的值总是大于父结点的值。因此我们在转换成排序双向链表时，原先指向左子结点的指针调整为链表中指向前一个结点的指针，原先指向右子结点的指针调整为链表中指向后一个结点指针。接下来我们考虑该如何转换。

由于要求转换之后的链表是排好序的，我们可以中序遍历树中的每一个结点， 这是因为中序遍历算法的特点是按照从小到大的顺序遍历二叉树的每一个结点。当遍历到根结点的时候，我们把树看成三部分：值为 10 的结点、根结点值为 6 的左子树、根结点值为 14 的右子树。根据排序链表的定义，值为 10 的结点将和它的左子树的最大一个结点（即值为 8 的结点）链接起来，同时它还将和右子树最小的结点（即值为 12 的结点）链接起来，

代码：

/*
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)
    {
TreeNode* pList=nullptr;
        preoder(pRootOfTree,&pList);
        return pList;
    }
    void preoder(TreeNode* pRootOfTree,TreeNode** pList){
        //先序遍历的反向遍历
        //右中左
        if(pRootOfTree==nullptr)return;
        if(pRootOfTree->right!=nullptr)
            preoder(pRootOfTree->right,pList);
        
        pRootOfTree->right=*pList;
        if(*pList!=nullptr)
            (*pList)->left=pRootOfTree;
        *pList=pRootOfTree;
        
        if(pRootOfTree->left!=nullptr)
            preoder(pRootOfTree->left,pList);
        
    }
};

27.字符串的排列

题目描述：

输入一个字符串,按字典序打印出该字符串中字符的所有排列。例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba。

思路：

这一题还是比较难的，但是看看图也就知道了，是应该运用递归来做。

把一个字符串看成由两部分组成：第一部分为它的第一个字符，第二部分是后面的所有字符。在图 4.14 中，我们用两种不同的背景颜色区分字符串的两部分。

我们求整个字符串的排列，可以看成两步：首先求所有可能出现在第一个位置的字符，即把第一个字符和后面所有的字符交换。图 4.14 就是分别把第一个字符 a 和后面的 b、c 等字符交换的情形。首先固定第一个字符（如图 4.14 (a ）所示〉，求后面所有字符的排列。这个时候我们仍把后面的所有字符分成两部分：后面字符的第一个字符，以及这个字符之后的所有字符。然后把第一个字符逐一和它后面的字符交换（如图 4.14 （b）所示）。。。。。。

这其实是很典型的递归思路。

顺带复习一下，break，continue的用法：

break可以在循环和switch中使用,程序执行到break语句时,如在break在循环中出现,则跳出当前层次的循环(只能跳出一层)继续执行循环外的一语句.如果在switch语句中出现,则结束switch,继续执行switch语句之后的语句.
continue只能用在循环中,意思是"继续"循环的意思.当程序执行到contnue时,流程会回到循环的头部,continue后面的的语句不会被执行.



代码：

class Solution {
public:
   vector<string>Permutation(string str){
       vector<string>vec;
       if(str=="")
           return vec;
       Perm(str,0,str.length(),vec);
       sort(vec.begin(),vec.end());
       return vec;
   }
    private:
    void swap(char& a,char& b){
        char temp=a;
        a=b;
        b=temp;
    }
    void Perm(string str,int begin,int end,vector<string>&vec)
        {
        if(begin==end)
            {
            vec.push_back(str);
        }else{
            for(int i=begin;i<end;++i)
                {
                if(i!=begin && str[begin]==str[i])
                    continue;
                swap(str[begin],str[i]);
                Perm(str,begin+1,end,vec);
                swap(str[begin],str[i]); 
            }
        }
        
    }
           
};
      

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

题目描述：

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。例如输入一个长度为9的数组{1,2,3,2,2,2,5,4,2}。由于数字2在数组中出现了5次，超过数组长度的一半，因此输出2。如果不存在则输出0。

思路：

这一题的这种方法太奇妙了，由于它是判断是否超过一半，因此用count是否为0来判断是否超过一半，超过一半自然这个count不会为0

还有一个需要注意的地方就是string.length()表示字符串的长度，vector.size()表示向量的大小


代码：

class Solution {
public:
    int MoreThanHalfNum_Solution(vector<int> numbers) {
    int count=1;
        int num;
        num=numbers[0];
        if(numbers.size()==0)return 0;
        for(int i=1;i<numbers.size();i++)
            {
            if(numbers[i]==num)
            {count++;}
            else
                count--;
            if(count==0)
                {
                num=numbers[i];
                count=1;
                
            }
                
        }
        count=0;
        for(int i=0;i<numbers.size();i++)
            {
            if(numbers[i]==num) count++;
            
            
        }
        if(2*count>numbers.size())
            return num;
        else
            return 0;
    }
};

29.最小的K个数

题目描述：

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4

思路：

这一题还是很简单的，虽然开始我没有考虑全面，首先要判断一下选取的k值是否合理，如果合理然后就利用sort函数进行排序即得到最终结果

这里需要注意的是sort函数是默认从小到大排序。


代码：

class Solution {
public:
    vector<int> GetLeastNumbers_Solution(vector<int> input, int k) {
        vector<int>res;
        if(k>input.size())
            return res;
        sort(input.begin(),input.end());
       
        for(int i=0;i<k;i++)
            {
            res.push_back(input[i]);
            
        }
        return res;
    }

};


30.连续子数组的最大和

题目描述：

HZ偶尔会拿些专业问题来忽悠那些非计算机专业的同学。今天测试组开完会后,他又发话了:在古老的一维模式识别中,常常需要计算连续子向量的最大和,当向量全为正数的时候,问题很好解决。但是,如果向量中包含负数,是否应该包含某个负数,并期望旁边的正数会弥补它呢？例如:{6,-3,-2,7,-15,1,2,2},连续子向量的最大和为8(从第0个开始,到第3个为止)。你会不会被他忽悠住？(子向量的长度至少是1)

思路：

基本思想就是用cur做当前的和值如果当前的和值比刚加进来的数值小，就说明刚才这个数值比前面的和值有价值，同时考察最大值，如果最大值小于和值那么和值就是最大值。


代码：

class Solution {
public:
    int FindGreatestSumOfSubArray(vector<int> array) {
    int cur=array[0];
        int max=array[0];
        for(int i=1;i<array.size();i++)
            {
            cur+=array[i];
            if(cur<array[i])
                cur=array[i];
            if(cur>max)
                max=cur;
            
        }
        return max;
    }
   
};
fmbao
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《剑指offer》算法总结
Zuoerfeng
11-09 4445
最近找工作，刷了下《剑指offer》这本书，上面有挺多经典的算法，对每一章做了一个总结，章节笔记见一下链接： http://note.youdao.com/noteshare?id=ad655fcf73eb4b63e7e0700daa01d02f 下面是对整本书的一个算法，从数据结构上进行分类，这样拿到算法题的时候知道从哪一个类别去思考相似的可能性。 一、线性表 1、数组 2、链表 二、字符串 三...
leetcode减绳子-lcof-go:LeetCodeCN剑指Offer做题记录
06-30
【标题】"leetcode减绳子-lcof-go:LeetCodeCN剑指Offer做题记录" 涉及的主要是编程领域的算法题目，特别是与LeetCode和《剑指Offer》相关的Go语言实现。LeetCode是一个在线的平台，它提供了一系列的编程问题来帮助...
JAVA-容器(5)-Map
weixin_30367543的博客
04-02 59
（基于JDK1.8源码分析） 一，Map接口 　　Map以键值对方式存储，key具有唯一性，元素顺序根据具体实现类不同，如：treeMap确保了存入顺序而hashMap没有确保存入顺序 　　源码分析： public interface Map<K,V> { int size(); boolean isEmpty(); boolean...
百度面试题——简要说明树的深度优先、广度优先遍历算法，及非递归实现的特点
qinghunya的专栏
09-10 6601
问题描述： 简要说明树的深度优先、广度优先遍历算法，及非递归实现的特点 解题思路： 树的遍历按遍历方式分为深度优先和广度优先遍历，并可采用递归和非递归两种遍历方式来进行。 深度优先：深度优先可分为前序遍历，中序遍历，以及后续遍历，其思想大体一致，都是先进行深层次某个节点的遍历，直到为空，然后再往上遍历其兄弟节点。深度优先一般采用递归的方式实现，递归的深度为树的高度。 广度优先：广度优先是
剑指 Offer做题总结
31楼下小黑的博客
11-29 137
题目 出错次数 剑指 Offer 41. 数据流中的中位数 2
力扣【剑指offer】题目汇总与总结
华辰烟雨的博客
08-06 2万+
本文为《剑指offer》刷题笔记的总结，花费不到两个月的时间将力扣上《剑指offer》的75道题刷了一遍，遇到不会的知识点或者应该做一些记录的题目都将其写在了往日的博客里。 整体来看，这75道题，涉及到常用的数据结构：数组、字符串、链表、栈、队列、树、图，还有一些常用的数据操作和算法：二分法、哈希表、递归、排序、查找、位运算、动态规划、回溯、滑动窗口、双指针、深度优先搜素（DFS）、贪心。 1、数组 （1）剑指offer03.数组中重复的数字。 （2）剑指offer04.二维数组中的查找。解法：找标
力扣-剑指offer所有题
qq_40214464的博客
03-08 5316
第27天 单向队列 剑指 Offer 59 - I. 滑动窗口的最大值https://leetcode-cn.com/problems/hua-dong-chuang-kou-de-zui-da-zhi-lcof/ 给定一个数组nums和滑动窗口的大小k，请找出所有滑动窗口里的最大值。 输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3 输出: [3,3,5,5,6,7] 解释: 滑动窗口的位置 最大值 ---------.....
剑指Offer题集（力扣）
qq_42958831的博客
05-07 1万+
力扣题单：https://leetcode.cn/problemset/all/?listId=lcof&page=1
剑指 Offer 总结 - leetcode 剑指offer系列
随便发挥的博客
08-31 2779
剑指 Offer 系列完结撒花!! ???????? 本篇文章是对整个系列的精华总结, 对系列的每篇文章进行了分类, 并用一句话概括每道题的思路, 方便大家理解和记忆, 当然也包含原文完整链接供大家参考 总的来说, 写这个系列耗费了我不少精力, 不过我也很开心能和大家分享, 真心希望能对大家有所帮助, 也希望大家能够多多点赞转发和分享, 让更多人看到, 谢谢~ 接下来我需要休整一段时间来准备新的系列了, 中间也可能会有一些不定期更新. 至于新系列是什么呢? 大家敬请期待 ???? P.S.
剑指offer所有的题目的总结
xuxinrk的博客
02-26 2226
目录 基本都是参考别的博客和书本的代码，仅作为自己笔记用！！ 零、小结： 一、位运算 1、二进制中1的个数 2、判断二进制中0的个数 3.二进制高位连续0的个数 二、二叉树 1、二叉搜索树第k个结点 2.0 从上往下打印二叉树 2.1二叉树打印成多行 2.2按之字形顺序打印二叉树 题目描述 3.数据流中位数 4.二叉树中和为某一值的路径 5.重建二叉树 6.树的子结...
剑指 offer 编程题 C++ 版总结(上)
Tyler_Zx的博客
11-14 1644
剑指 offer 编程题总结(上)
剑指offer算法题Python源码带详细思路注释（68道）.zip
最新发布
04-28
翻转单词顺序列,反转链表,斐波那契数列,复杂链表的复制,构建乘积数组,和为s的连续整数序列,和为s的两个数字,滑动窗口的最大值,机器人的运动范围,剑指offer-python实现.docx,矩形覆盖,矩阵中的路径,连续子数组的最大...
剑指offer面试题python题解（做题记录）.zip
11-14
python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 python面试题、知识点，用于程序员应聘学习参考，提供代码+题型等资料 ...
jianzhi-offer:剑指offer面试题-javascript版源码与测试用例
05-09
剑指offer部分面试题使用javascript实现，配合grunt，使用karma和jasmine完成自动测试，使用jshint做代码检测。 面试题 面试题03：二维数组中的查找 面试题06：重建二叉树 面试题08：旋转数组中的最小数 面试题10：...
LeetCode&&剑指offer 面试题32 – III. 从上到下打印二叉树 III 我的解题记录
12-21
本题的关键在于理解如何灵活运用队列和栈来控制遍历顺序，以及在层次遍历的过程中动态调整节点的添加方式。通过这种方式，我们可以实现从上到下，同时根据需求改变左右子节点遍历顺序的二叉树层次打印。这个解题思路...
vs2017 找不到源文件stdio.h解决方法
热门推荐
fmbao的博客
06-23 4万+
这个问题网上又不少人提出。我的vs出现这个问题是因为我电脑重装系统了，原来的项目所采用windows SDK 已经发生了变化。因此解决的办法是：项目-&gt;属性-&gt;配置属性-&gt;常规-&gt;windows SDK版本。将其换成你现在的版本即可解决问题。...
Qt多窗口切换实战与注意点（附详细代码与Qt资料）
fmbao的博客
05-08 1万+
太兴奋了，花了一天时间，终于把一个demo调通了，掉了无数个坑，无论是看书还是看网络上的一些帖子，坑无数。本人也是刚接触Qt，就四五天吧。现在经过一些坑的洗礼，终于可以慢慢入门了，兴奋啊，吼啊，不禁让我在朋友圈分享了一首FB的歌呢。当然网上不全是坑，也发现了非常精华的内容，比如这篇博客《Qt资料大全》，非常适合Qt小白。 本人极力推荐《Qt Creator快速入门》以及配套的相关代码，我已经将这...
Ubuntu上vscode调试C/C++代码
fmbao的博客
05-22 3579
这篇文章起初是我看了一个B站的视频，作者讲述了如何在Ubuntu的 环境中通过使用vscode调试C/C++代码。 这个教程非常好，也非常推荐给大家，但是这个教程有一个局限性，就是他在他的公共号上写的教程非常简略，以至于我想再次看一遍，需要重新看一遍视频，非常低效，所以我打算根据这位大佬的视频教程，写一篇博客，这样方便自己，也方便大家。 当然大家在网上也会搜到和我标题差不多的教程，但是我都看了一遍，都挺狗的，写的非常简略，你按照他们的教程基本就学的一个寂寞。 不过这里面也有挺多坑的，一般不自己梳理一遍很容易
C++进阶内容（函数模板、类模板、STL、算法)
fmbao的博客
08-18 2679
C++进阶内容（函数模板、类模板、STL、算法） C++进阶内容（函数模板、类模板、STL、算法） STL特点 STL数据结构类型 string相关操作 vector相关操作 queue相关操作 stack相关操作 queue相关操作 list相关操作 set和multiset相关操作 set和multiset相关操作 STL特点 STL具有高可重用性，高性能，高移植性...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值