【C++】leetcode力扣 剑指 Offer 题解

企业开发 2023-07-01 07:11:00 阅读次数: 0

文章预览：

力扣链接

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

法一：暴力解法
使用两层循环，超时

class Solution {
    
    
public:
    int findRepeatNumber(vector<int>& nums) {
    
    
        
        for(int i=0;i<nums.size();i++){
    
    
            for(int j=i+1;j<nums.size();j++){
    
    
                if(nums[j]==nums[i]){
    
    
                    return nums[i];
                }
            }
        }
    return 0;
    }
};

法二：使用unordered_map计数

class Solution {
    
    
public:
    int findRepeatNumber(vector<int>& nums) {
    
    
        unordered_map<int,int> m;

        for(int i=0;i<nums.size();i++){
    
    
            if(m.find(nums[i])!=m.end()){
    
    //如果存在说明出现重复的
                return nums[i];
            }
            m[nums[i]]++;//记录每个数字出现的次数
        }
        
    return -1;
    }
};

剑指 Offer 04. 二维数组中的查找

class Solution {
    
    
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
    
    
        
        int max_x=matrix.size();//二维数组行数
        if(max_x==0) return false;//注意特殊情况的判断
        int max_y=matrix[0].size();//二维数组列数
        for(int i=0;i<max_x;i++){
    
    
            for(int j=0;j<max_y;j++){
    
    
                if(matrix[i][j]>target){
    
    //说明第j列之后的列（包括第j列）都大于target
                    max_y=j;//更新能到达的最大列
                }
                else if(matrix[i][j]==target){
    
    
                    return true;
                }
                else continue;//小于，继续遍历
            }
        }
        return false;
    }
};

剑指 Offer 05. 替换空格

法一：创建新字符串result存放

class Solution {
    
    
public:
    string replaceSpace(string s) {
    
    
        string result="";
        for(char c:s){
    
    
            if(c==' '){
    
    
                result+="%20";
            }
            else{
    
    
                result+=c;
            }
        }
        return result;
    }
};

法二：使用双指针原地操作

class Solution {
    
    
public:
    string replaceSpace(string s) {
    
    
        //双指针
        int cout=0;
        for(char c:s){
    
    
            if(c==' ') cout++;
        }
        int i=s.size()-1;
        s.resize(s.size()+2*cout);
        int j=s.size()-1;
        for(i,j;i>=0;i--){
    
    
            if(s[i]==' '){
    
    
                s[j]='0';
                s[j-1]='2';
                s[j-2]='%';
                j=j-3;
            }
            else{
    
    
                s[j--]=s[i];
            }
        }
        return s;
    }
};

剑指 Offer 06. 从尾到头打印链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    vector<int> reversePrint(ListNode* head) {
    
    
        vector<int> result;
        while(head){
    
    
            result.push_back(head->val);
            head=head->next;
        }
        for(int i=0,j=result.size()-1;i<j;i++,j--){
    
    //使用双指针反转数组
            swap(result[i],result[j]);
        }
        return result;
    }
};

剑指 Offer 07. 重建二叉树

题目给了双向链表节点的结构体
采用递归思想来写代码，每次递归传入的前序遍历和中序遍历的数组都是去掉的head节点之后的左子树的前序遍历和中序遍历数组、右子树的前序遍历和中序遍历数组

/**
 * 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* buildTree(vector<int>& preorder, vector<int>& inorder) {
    
    
        if(preorder.size()==0) return NULL;

        TreeNode* head=new TreeNode(preorder[0]);//前序遍历的第一个值就是根节点val值

        vector<int> left_inorder;//head节点的左子树的中序遍历结果
        vector<int> right_inorder;//head节点的右子树的中序遍历结果
        int i=0;
        for(;i<inorder.size();i++){
    
    
            if(inorder[i]==preorder[0]) break;
            left_inorder.push_back(inorder[i]);
        }
        i++;//记得加一跳过根节点，因为break不会执行i++
        for(;i<inorder.size();i++){
    
    
            right_inorder.push_back(inorder[i]);
        }

        vector<int> left_pre;//head节点的左子树的前序遍历结果
        vector<int> right_pre;//head节点的右子树的前序遍历结果
        int j=1;
        for(;j<1+left_inorder.size();j++){
    
    
            left_pre.push_back(preorder[j]);
        }
        for(;j<preorder.size();j++){
    
    
            right_pre.push_back(preorder[j]);
        }

        head->left=buildTree(left_pre,left_inorder);
        head->right=buildTree(right_pre,right_inorder);

        return head;
    }
};

剑指 Offer 09. 用两个栈实现队列

class CQueue {
    
    
public:
    stack<int> st;//存放和队列顺序一样的值
    stack<int> temp;//中转栈
    CQueue() {
    
    
        
    }
    
    void appendTail(int value) {
    
    //队列尾部插入整数
      
        while(!st.empty()){
    
    
            int val=st.top();
            st.pop();
            temp.push(val);
        }
        temp.push(value);
        while(!temp.empty()){
    
    
            int val=temp.top();
            temp.pop();
            st.push(val);
        }
    }
    
    int deleteHead() {
    
    //队列头部删除整数
        if(st.size()==0) return -1;
        int val=st.top();
        st.pop();
        return val;
    }
};


/**
 * Your CQueue object will be instantiated and called as such:
 * CQueue* obj = new CQueue();
 * obj->appendTail(value);
 * int param_2 = obj->deleteHead();
 */

剑指 Offer 10- I. 斐波那契数列

使用动态规划
注意在循环里面每一步的结果都应该取模后再进行赋值，而不应该最后return的时候再取模，会溢出

class Solution {
    
    
public:
    int fib(int n) {
    
    
        if(n==0) return 0;
        vector<int> dp(n+1,0);
        dp[0]=0;dp[1]=1;
        for(int i=2;i<dp.size();i++){
    
    
            dp[i]=(dp[i-1]+dp[i-2])%1000000007;
        }
        return dp[n];
    }
};

剑指 Offer 10- II. 青蛙跳台阶问题

class Solution {
    
    
public:
    int numWays(int n) {
    
    
        if(n==0) return 1;
        vector<int> dp(n+1,0);
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<dp.size();i++){
    
    
            dp[i]=(dp[i-1]+dp[i-2])%1000000007;
        }
        return dp[n];
    }
};

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

法一：
一开始想的是对数组进行排序，利用sort函数返回第一个元素,以为会超时，结果没有

class Solution {
    
    
public:
    int minArray(vector<int>& numbers) {
    
    
        sort(numbers.begin(),numbers.end());
        return numbers[0];
    }
};

法二：对法一优化一下，循环查找，直到找到第一个比前一个数小的就返回

class Solution {
    
    
public:
    int minArray(vector<int>& numbers) {
    
    
        int num=numbers[0];
        for(int i=1;i<numbers.size();i++){
    
    
            if(numbers[i]<numbers[i-1]){
    
    
                num=numbers[i];
                break;
            }
        }
        return num;
    }
};

剑指 Offer 12. 矩阵中的路径

第一遍写的代码是有问题的
比如word="SEE"时
代码相当于只考虑了一种情况，S找到上面E后继续循环，然后返回false，这样是有问题的，其实下面的E完全没考虑到
在这里插入图片描述

class Solution {
    
    
public:
    bool is_true(vector<vector<char>>& board,string word,int index_i,int index_j){
    
    
        //i,j是word第一个字母在board中的位置
        int m=board.size();
        int n=board[0].size();
        vector<vector<bool>> is_used(m,vector<bool>(n,false));//判断某个位置是否已经使用过了，false代表没使用
        for(int i=1;i<word.size();i++){
    
    
            //判断上下左右的位置是否有符合要求的
            //上面
            if(index_i-1>=0&&is_used[index_i-1][index_j]==false&&board[index_i-1][index_j]==word[i]){
    
    //不能超限&&上方格子未使用
                    is_used[index_i-1][index_j]=true;
                    index_i--;
                    continue;
            }
            //下面
            if(index_i+1<m&&is_used[index_i+1][index_j]==false&&board[index_i+1][index_j]==word[i]){
    
    //不能超限&&下方格子未使用
                    is_used[index_i+1][index_j]=true;
                    index_i++;
                    
                    continue;
            } 
            //左边
            if(index_j-1>=0&&is_used[index_i][index_j-1]==false&&board[index_i][index_j-1]==word[i]){
    
    //不能超限&&左边格子未使用
                    index_j--;
                    is_used[index_i][index_j]=true;
                    continue;
            
            } 
            //右边
            if(index_j+1<n&&is_used[index_i][index_j+1]==false&&board[index_i][index_j+1]==word[i]){
    
    //不能超限&&右边格子未使用
      
                    index_j++;
                    is_used[index_i][index_j]=true;
                    continue;
            
            }
            return false;//四个格子都不符合
        
        }
        return true;
    }
    bool exist(vector<vector<char>>& board, string word) {
    
    
        for(int i=0;i<board.size();i++){
    
    
            for(int j=0;j<board[0].size();j++){
    
    
                if(board[i][j]==word[0]){
    
    
                    bool label=is_true(board,word,i,j);
                    if(label) return true;
                    else continue;
                }
            }
        }
        return false;
    }
};

改正后：使用递归进行改正
dfs经典例子

class Solution {
    
    
public:

    bool is_true(vector<vector<char>>& board,string word,int index,int index_i,int index_j,vector<vector<bool>> &is_used){
    
    
        //index_i,index_j是index-1位置的字母在board中的位置
        //index是word中本次要比较的下标
        if(index==word.size()) return true;//说明前面的字母都符合要求，返回true

        int m=board.size();
        int n=board[0].size();
        bool label1=false;
        bool label2=false;
        bool label3=false;
        bool label4=false;

        //搜索上下左右的位置是否有=word[index]的
        //上面
        if(index_i-1>=0&&is_used[index_i-1][index_j]==false&&board[index_i-1][index_j]==word[index]){
    
    //不能超限&&上方格子未使用
            is_used[index_i-1][index_j]=true;
            label1=is_true(board,word,index+1,index_i-1,index_j,is_used);
            is_used[index_i-1][index_j]=false;
                 
        }
        //下面
        if(index_i+1<m&&is_used[index_i+1][index_j]==false&&board[index_i+1][index_j]==word[index]){
    
    //不能超限&&下方格子未使用
            is_used[index_i+1][index_j]=true;
            label2=is_true(board,word,index+1,index_i+1,index_j,is_used);
            is_used[index_i+1][index_j]=false;    
                  
        } 
        //左边
        if(index_j-1>=0&&is_used[index_i][index_j-1]==false&&board[index_i][index_j-1]==word[index]){
    
    //不能超限&&左边格子未使用      
            is_used[index_i][index_j-1]=true;
            label3=is_true(board,word,index+1,index_i,index_j-1,is_used);
            is_used[index_i][index_j-1]=false;                      
        } 
        //右边
        if(index_j+1<n&&is_used[index_i][index_j+1]==false&&board[index_i][index_j+1]==word[index]){
    
    //不能超限&&右边格子未使用          
            is_used[index_i][index_j+1]=true;
            label4=is_true(board,word,index+1,index_i,index_j+1,is_used);
            is_used[index_i][index_j+1]=false;                        
        }
           
        bool label=label1||label2||label3||label4;//只要有一个方向找到了就可以
        return label;
    }
    bool exist(vector<vector<char>>& board, string word) {
    
    
        int m=board.size();
        int n=board[0].size();
        vector<vector<bool>> is_used(m,vector<bool>(n,false));//判断某个位置是否已经使用过了，false代表没使用
        for(int i=0;i<board.size();i++){
    
    
            for(int j=0;j<board[0].size();j++){
    
    
                if(board[i][j]==word[0]){
    
    
                    is_used[i][j]=true;
                    //根据is_true函数参数的定义，这里必须要先对word[0]进行判断后才可以调用这个递归函数
                    bool label=is_true(board,word,1,i,j,is_used);
                    is_used[i][j]=false;
                    if(label) return true;                    
                }

            }
        }
        return false;
    }
};

剑指 Offer 13. 机器人的运动范围

这道题如果这样思考就是错误的：直接两层for循环嵌套判断每个格子的数位之和是否大于k
其实有些格子数位之和大于k之后它就成了障碍物，比如m=16，n=8，k=4，期望输出是15，（10，0）数位之和小于4，看似符合要求，其实并不符合要求，因为前面某些行整行都是障碍物，根本没办法到达（10，0）这个点

正确做法如下：使用深度优先搜索dfs算法

class Solution {
    
    
public:
    int sum=1;//[0,0]位置肯定是符合的
    void dfs(int m, int n, int k,vector<vector<bool>> &is_used,int index_i,int index_j){
    
    
        //index_i,index_j是当前要搜索的位置
        //向上走
        if(index_i-1>=0&&is_used[index_i-1][index_j]==false){
    
    
            if((index_i-1)/10+(index_i-1)%10+index_j/10+index_j%10<=k){
    
    
                sum++;
                is_used[index_i-1][index_j]=true;
                dfs(m,n,k,is_used,index_i-1,index_j);

                //注意这道题并不需要回溯，因为能运行到这里都是符合要求的方格，需要计算出所有符合要求的方格
                // is_used[index_i-1][index_j]=false;
                // sum--;
            }
            
        }
        //向下走
        if(index_i+1<m&&is_used[index_i+1][index_j]==false){
    
    
            if((index_i+1)/10+(index_i+1)%10+index_j/10+index_j%10<=k){
    
    //说明下面的格子符合要求
                sum++;
                is_used[index_i+1][index_j]=true;
                dfs(m,n,k,is_used,index_i+1,index_j);

            }
            
        }
        //向左走
        if(index_j-1>=0&&is_used[index_i][index_j-1]==false){
    
    
            if(index_i/10+index_i%10+(index_j-1)/10+(index_j-1)%10<=k){
    
    
                sum++;
                is_used[index_i][index_j-1]=true;
                dfs(m,n,k,is_used,index_i,index_j-1);

            }
            
        }
        //向右走
        if(index_j+1<n&&is_used[index_i][index_j+1]==false){
    
    
            if(index_i/10+index_i%10+(index_j+1)/10+(index_j+1)%10<=k){
    
    
                sum++;
                is_used[index_i][index_j+1]=true;
                dfs(m,n,k,is_used,index_i,index_j+1);

            }
            
        }
    }
    int movingCount(int m, int n, int k) {
    
    

        vector<vector<bool>> is_used(m,vector<bool>(n,false));
        is_used[0][0]=true;
        dfs(m,n,k,is_used,0,0);
        return sum;
    }
};

剑指 Offer 14- I. 剪绳子

class Solution {
    
    
public:
    int cuttingRope(int n) {
    
    
        //dp[i]:拆分正整数i（至少分成两段），能得到的最大乘积
        //(i-j)*j相当于是把i分为两个数，而dp[i-j]*j相当于是把i拆分成三个数及以上，因为dp拆分个数>=2     
        vector<int> dp(n+1,1);
        for(int i=2;i<=n;i++){
    
    
            for(int j=i-1;j>=1;j--){
    
    
                dp[i]=max(j*(i-j),max(dp[i],dp[i-j]*j));
            }
            
        }
        return dp[n];

    }
};

剑指 Offer 15. 二进制中1的个数

class Solution {
    
    
public:
    int hammingWeight(uint32_t n) {
    
    
        int sum=0;
        while(n){
    
    
            if(n%2==1){
    
    //判断最末尾的数是否为1
                sum++;
            }
            n=n/2;//左移一位
        }
        return sum;
    }
};

剑指 Offer 16. 数值的整数次方

使用快速幂算法
快速幂算法介绍
代码如下：
核心思想：利用二进制来加快运算

class Solution {
    
    
public:
    double myPow(double x, int n) {
    
    
        //快速幂算法
        if( n == 0) return 1;
        if( x == 0.0) return 0;
        long  exp = n;//
        if(n < 0) {
    
    
            //int的取值范围：-2147483648～2147483647
            exp = n* (-1.0);
            //当n == INT_MIN时正数时大于INT_MAX的，所以要用一个大于 INT_MAX的类型来保存，同时在将他转正的时候， n*(-1)的结果依然是一个 int，此时的int是个隐藏类型，然后才将这个结果赋值给 exp，所以用来保存结果值的不应该是个int型，我们用double型的 -1 ,这样就可以将相乘的结果值保存为一个 double类型了，然后再进行赋值
        } 
        
        double res = 1.0;
        while(exp != 0){
    
    
            if( (exp &1) == 1 ){
    
    //指数为奇数，exp & 1这相当于exp % 2 == 1
            //如果二进制位是0的话相当于乘上1，可以不用管
                res *=x;
            }
            x *=x;//2^0,2^1,2^2,2^4....
            exp >>= 1;//右移一位，相当于除以2
            //一次的右移将舍弃一个位例如1011(2)一次左移后变成101(2)
        }

        return n<0 ? 1/res: res;
    }
};

剑指 Offer 17. 打印从1到最大的n位数

class Solution {
    
    
public:
    vector<int> printNumbers(int n) {
    
    
        
        int num=1;
        for(int i=0;i<n;i++){
    
    
            num*=10;//计算出最大的n位数+1的值
        }
        vector<int> result(num-1,0);
        for(int i=1;i<num;i++){
    
    
            result[i-1]=i;
        }
        return result;
    }
};

剑指 Offer 18. 删除链表的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* deleteNode(ListNode* head, int val) {
    
    
        ListNode* virtul_head=new ListNode(0);
        virtul_head->next=head;//虚拟头节点
        ListNode* temp=head;
        ListNode* pre=virtul_head;//前一个节点
        while(temp){
    
    
            if(temp->val==val){
    
    
                pre->next=temp->next;
                break;
            }
            //更新前一个节点和当前节点
            pre=temp;
            temp=temp->next;
        }
        return virtul_head->next;
    }
};

剑指 Offer 20. 表示数值的字符串

感觉在做这道题的时候就是在面向用例编程，要考虑的情况很多

class Solution {
    
    
public:
    bool isNumber(string s) {
    
    
        //出现其他字母为false
        int j=0;
        while(s[j]==' '){
    
    
            j++;
        }

        //跳过小数和整数的符号位
        if(s[j]=='+'||s[j]=='-'){
    
    
            j++;
        }
        int i=j;

        if(i==s.size()) return false;

        //处理小数和整数，保证i指向小数或者整数的第一个数字的位置
        if(s[i]=='.'){
    
    
            if(i==s.size()-1) return false;
            //小数点前面是至少一位数字
            int index=i;
            while(i+1<s.size()&&s[i+1]<='9'&&s[i+1]>='0') i++;//跳到后面跟着的数字的位置
            if(index==i) return false;//后面跟着0个数字
        }
        else if(s[i]<='9'&&s[i]>='0'){
    
    
            if(i==s.size()-1) return true;
            while(i+1<s.size()&&s[i+1]<='9'&&s[i+1]>='0') i++;//跳到后面跟着的数字位置            
            if(i+1<s.size()&&s[i+1]=='.'){
    
    
                i++;
                i++;//跳到小数点后面的一位
                
            }
        }

        //跳过i位置开始的数字
        while((i<s.size()&&s[i]<='9'&&s[i]>='0')){
    
    
            i++;
        }
        if(i==s.size()) return true;//说明只有小数或整数
        if(i==j) return false;//说明没有小数或整数（必选）
        if(s[i]=='e'||s[i]=='E'){
    
    
            i++;
            if(i==s.size()) return false;
            if(s[i]=='+'||s[i]=='-'){
    
    
                i++;
                if(i==s.size()) return false;//说明符号位后面没有跟数字 
            }
            int temp=i;           
            while(i<s.size()&&s[i]<='9'&&s[i]>='0'){
    
    
                i++;
            }
            if(i==s.size()) return true;
           if(i==temp) return false;//说明后面没有数字
        }
        while(s[i]==' '){
    
    //后面跟着的空格
            i++;
        }
        if(i==s.size()) return true;//说明都是空格
        else return false;
        
    }
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面

设计一个新数组和双指针来存放奇偶数

class Solution {
    
    
public:
    vector<int> exchange(vector<int>& nums) {
    
    
        if(nums.size()<=1) return nums;
        vector<int> result(nums.size(),0);
        int slow=0;
        int fast=nums.size()-1;
        for(int i=0;i<nums.size();i++){
    
    
            if(nums[i]%2==1){
    
    //奇数
                result[slow++]=nums[i];
            }
            else{
    
    
                result[fast--]=nums[i];
            }
        }
        return result;
    }
};

剑指 Offer 22. 链表中倒数第k个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
    
    
        int size=1;//节点个数
        ListNode* temp=head;
        while(temp->next){
    
    
            temp=temp->next;
            size++;
        }
        temp=head;
        int path=size-k;//需要走的步数
        while(path--){
    
    
            temp=temp->next;
        }
        return temp;
    }
};

剑指 Offer 24. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* reverseList(ListNode* head) {
    
    
        ListNode* pre=NULL;
        while(head){
    
    //两两交换
            ListNode* next=head->next;
            head->next=pre;
            pre=head;
            head=next;
        }
        return pre;
    }
};

剑指 Offer 25. 合并两个排序的链表

建立新链表，两两比较节点值

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    
    
        ListNode* virtual_head=new ListNode(0);
        ListNode* temp=virtual_head;
        while(l1&&l2){
    
    
            ListNode* node=new ListNode(0);
            if(l1->val<=l2->val){
    
    
                node->val=l1->val;
                l1=l1->next;
                
            }
            else{
    
    
                node->val=l2->val;
                l2=l2->next;

            }
            temp->next=node;
            temp=temp->next;
        }
        if(l1){
    
    
            temp->next=l1;
        }
        if(l2){
    
    
            temp->next=l2;
        }
        return virtual_head->next;
    }
};

剑指 Offer 26. 树的子结构

/**
 * 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 is_true(TreeNode* A, TreeNode* B){
    
    
        //使用递归判断树的结构是否相等
        if(B==NULL) return true;
        if(A==NULL) return false;
        if(A->val!=B->val) return false;
        bool left=false;
        bool right=false;
        left=is_true(A->left,B->left);
        right=is_true(A->right,B->right);
        return left&&right;//左右子树结构都相等才是true

    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
    
    
        //使用层次遍历法判断每一个节点的值是否和B的根节点的值相等
        //如果相等就执行判断函数
        if(A==NULL||B==NULL) return false;
        queue<TreeNode*> que;
        que.push(A);
        while(!que.empty()){
    
    
            int size=que.size();
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                que.pop();
                if(node->val==B->val){
    
    
                    if(is_true(node,B)) return true;
                }
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            
        }
        return false;
    }
};

剑指 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;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
    
    
            int size=que.size();
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                que.pop();
                TreeNode* temp=node->left;
                node->left=node->right;
                node->right=temp;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return root;
    }
};

剑指 Offer 28. 对称的二叉树

/**
 * 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 is_syem(TreeNode* left,TreeNode* right){
    
    
        //使用递归进行判断
        if(left==NULL&&right==NULL) return true;
        if(left==NULL) return false;//只有左边为空
        if(right==NULL) return false;
        if(left->val!=right->val) return false;

        //左右节点的值都是相等的
        bool label1=is_syem(left->left,right->right);
        bool label2=is_syem(left->right,right->left);

        return label1&&label2;

    }
    bool isSymmetric(TreeNode* root) {
    
    
        if(root==NULL) return true;
        return is_syem(root->left,root->right);
    }
};

剑指 Offer 30. 包含min函数的栈

class MinStack {
    
    
public:
    /** initialize your data structure here. */
    stack<int> st;
    map<int,int> m;//map会自动排序，key是插入的数，value是这个数的个数
    MinStack() {
    
    

    }
    
    void push(int x) {
    
    
        st.push(x);
        m[x]++;
    }
    
    void pop() {
    
    
        int val=st.top();
        m[val]--;
        st.pop();
    }
    
    int top() {
    
    
        return st.top();
    }
    
    int min() {
    
    
        int min_num=0;
        for(auto it=m.begin();it!=m.end();it++){
    
    
            if(it->second>0){
    
    //第一个就是最小值
                min_num=it->first;
                break;
            }
        }
        return min_num;
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack* obj = new MinStack();
 * obj->push(x);
 * obj->pop();
 * int param_3 = obj->top();
 * int param_4 = obj->min();
 */

剑指 Offer 31. 栈的压入、弹出序列

根据给定的数组模拟栈的压入、弹出过程

class Solution {
    
    
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
    
    
        stack<int> st;
        int j=0;
        for(int i=0;i<pushed.size();i++){
    
    
            st.push(pushed[i]);
            while(!st.empty()&&popped[j]==st.top()){
    
    //如果要弹出
                st.pop();
                j++;
            }
        }
        if(st.empty()) return true;//如果最后所有元素都弹出去了，说明弹出顺序是正确的
        return false;
    }
};

剑指 Offer 32 - 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:
    vector<int> levelOrder(TreeNode* root) {
    
    
        //层次遍历法
        vector<int> result;
        if(root==NULL) return result;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
    
    
            
            int size=que.size();
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                result.push_back(node->val);
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

剑指 Offer 32 - II. 从上到下打印二叉树 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
    
    
        vector<vector<int>> result;
        if(root==NULL) return result;
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
    
    
            int size=que.size();
            vector<int> temp;
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                que.pop();
                temp.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(temp);
        }
        return result;
    }
};

剑指 Offer 32 - III. 从上到下打印二叉树 III

注意这道题是整个一行的顺序反过来，而不是只对一个节点的左右节点交换顺序
错误写法：

/**
 * 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>> levelOrder(TreeNode* root) {
    
    
        vector<vector<int>> result;
        if(root==NULL) return result;
        bool label=false;//true:从左到右的顺序打印  false:从右到左的顺序
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
    
    
            int size=que.size();
            vector<int> temp;
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                que.pop();
                temp.push_back(node->val);
                if(!label){
    
    
                    if(node->right) que.push(node->right);
                    if(node->left) que.push(node->left);
                }
                else{
    
    
                    if(node->left) que.push(node->left);
                    if(node->right) que.push(node->right);
                }
            }
            label=~label;
            result.push_back(temp);

        }
        return result;
    }
};

正确写法

/**
 * 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>> levelOrder(TreeNode* root) {
    
    
        vector<vector<int>> result;
        if(root==NULL) return result;
        bool label=true;//true:从左到右的顺序打印  false:从右到左的顺序
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
    
    
            int size=que.size();
            vector<int> temp;
            for(int i=0;i<size;i++){
    
    
                TreeNode* node=que.front();
                que.pop();
                temp.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                
            }
            if(label==false) reverse(temp.begin(),temp.end());
            label=!label;
            result.push_back(temp);

        }
        return result;
    }
};

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

class Solution {
    
    
public:
    bool trans(vector<int>& postorder,int start,int end){
    
    
        //[start,end]
        if(end-start<=1) return true;
        int root=postorder[end];//根节点的值
        int i=start;
        for(;i<end;i++){
    
    
            if(postorder[i]>root) break;
        }
        //i为右子树的起始位置
        for(int j=i;j<end;j++){
    
    
            if(postorder[j]<root) return false;

        }
        bool left=trans(postorder,start,i-1);
        bool right=trans(postorder,i,end-1);
        return left&&right;

    }
    bool verifyPostorder(vector<int>& postorder) {
    
    
        //后序遍历：左右中
        if(postorder.size()==0) return true;
        return trans(postorder,0,postorder.size()-1);

    }
};

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

采用递归进行寻找，由于节点值可能为负，所以在判断返回条件的时候不能说当前target<0就返回

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    
    
public:
    vector<vector<int>> result;
    void look_target(TreeNode* node,int target,vector<int> &path){
    
    
        if(node->left==NULL&&node->right==NULL&&target==0){
    
    
            result.push_back(path);
            return;
        }
        if(node->left){
    
    
            int val=node->left->val;
            path.push_back(val);
            look_target(node->left,target-val,path);
            path.pop_back();
        }
        if(node->right){
    
    
            int val=node->right->val;
            path.push_back(val);
            look_target(node->right,target-val,path);
            path.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int target) {
    
    
        if(root==NULL) return result;
        vector<int> path;
        path.push_back(root->val);
        look_target(root,target-root->val,path);
        return result;
        
    }
};

剑指 Offer 35. 复杂链表的复制

/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/
class Solution {
    
    
public:
    Node* copyRandomList(Node* head) {
    
    
        if(head==NULL) return NULL;
        Node* new_head=new Node(head->val);//因为是复制，所以必须new一个新地址充当复制链表的头结点
        Node* temp=new_head;
        Node* virtual_head=new Node(0);//原链表的虚拟头结点
        virtual_head->next=head;
        //先处理next节点的指向
        while(head->next){
    
    
            Node* next=new Node(head->next->val);//因为是复制，所以必须new一个新地址
            temp->next=next;
            head=head->next;
            temp=temp->next;
        }
        //处理random节点的指向
        head=virtual_head->next;//原链表中的处理节点
        temp=new_head;//复制链表中的处理节点
        while(head){
    
    
            if(head->random==NULL){
    
    
                head=head->next;
                temp=temp->next;
                continue;
            }
            //注意这里不能判断val值是否相等，因为多个节点中的val值可能相等，所以会导致random指针指向错误
            int gap=0;//头节点距离random节点有多远
            Node* node_gap=virtual_head->next;//这里不是head，head只是处理过程的一个节点
            while(node_gap!=head->random){
    
    //找到地址相同的
                node_gap=node_gap->next;
                gap++;
            }
            
            Node* node=new_head;
            while(gap--) node=node->next;
            temp->random=node;
            head=head->next;
            temp=temp->next;
        }
        return new_head;
    }
};

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

/*
// 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:
    vector<Node*> vec;//存放中序遍历结果
    void mid_look(Node* node){
    
    
        //中序遍历的结果就是按照节点值从小到大的顺序
        if(node==NULL){
    
    
            return;
        }
        
        mid_look(node->left); 
        vec.push_back(node);
        mid_look(node->right);
        
    }
    Node* treeToDoublyList(Node* root) {
    
    
        if(root==NULL) return NULL;
        mid_look(root);
        for(int i=0;i<vec.size()-1;i++){
    
    
            Node* node=vec[i];
            Node* next=vec[i+1];
            node->right=next;
            next->left=node;
        }
        vec[vec.size()-1]->right=vec[0];
        vec[0]->left=vec[vec.size()-1];

        return vec[0];
    }
};

剑指 Offer 38. 字符串的排列

去重可以参考下面的讲解：
全排列去重

class Solution {
    
    
public:
    vector<string> result;
    void permu(string s,string path,vector<int> &used_char){
    
    
        if(path.size()==s.size()){
    
    
            result.push_back(path);
            return;
        }
        for(int i=0;i<s.size();i++){
    
    
            if(i>0&&s[i]==s[i-1]&&used_char[i-1]==0) continue;//同树层相同元素去重
            if(used_char[i]==0){
    
    //代表还没用过
               used_char[i]=1; 
               path+=s[i];
               permu(s,path,used_char);
               path.pop_back();
               used_char[i]=0;
            }

        }
    }
    vector<string> permutation(string s) {
    
    
        string path="";
        sort(s.begin(),s.end());
        vector<int> used_char(s.size(),0);
        permu(s,path,used_char);
        return result;
    }
};

剑指 Offer 40. 最小的k个数

法一：直接使用api
sort函数的排序方法类似于快排方法，时间复杂度为n*log2(n)

class Solution {
    
    
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
    
    
        vector<int> result(k,0);
        sort(arr.begin(),arr.end());
        for(int i=0;i<k;i++){
    
    
            result[i]=arr[i];
        }
        return result;
    }
};

法二：使用快排

class Solution {
    
    
public:
        // 快速排序 不稳定排序  时间复杂度O（n*log n），空间复杂度O(logn)(递归会使用栈）
        //1、选取第一个数为基准
        //2、将比基准小的数交换到前面，比基准大的数交换到后面
        //3、对左右区间重复第二步，直到各区间只有一个数
    void quickSort(vector<int>& vec,int index_start,int index_end){
    
    
        //使用递归 传入整个数组和需要处理的数据起始位置[index_start，index_end]
        if(index_end-index_start<=0) return;//区间内只有一个数
        int index=index_start;
        for(int i=index_start+1;i<=index_end;i++){
    
    
            if(vec[i]<vec[index]){
    
    
                //把vec[i]的值换到index前面去
                for(int j=i;j>index;j--){
    
    
                    swap(vec[j],vec[j-1]);
                }
                
                index++;//更新基准的位置
            }
        }
        quickSort(vec,index_start,index-1);
        quickSort(vec,index+1,index_end);
    }
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
    
    
        vector<int> result(k,0);
        quickSort(arr,0,arr.size()-1);
        for(int i=0;i<k;i++){
    
    
            result[i]=arr[i];
        }
        return result;
    }
};

剑指 Offer 42. 连续子数组的最大和

使用前缀和的思想

class Solution {
    
    
public:
    int maxSubArray(vector<int>& nums) {
    
    
        int max=nums[0];
        int result=0;
        for(int i=0;i<nums.size();i++){
    
    
            result+=nums[i];
            if(result>max){
    
                  
                max=result;               
            }
            if(result<0){
    
    
                result=0;
            }
        }
        return max;
    }
};

剑指 Offer 45. 把数组排成最小的数

class Solution {
    
    
public:
    bool static cmp(int a,int b){
    
    
        //按照a和b转换成string字符串结合起来的最小结果来决定a和b的前后位置
        string s1=to_string(a);
        string s2=to_string(b);
        return (s1+s2)<(s2+s1);
    }
    string minNumber(vector<int>& nums) {
    
    
        sort(nums.begin(),nums.end(),cmp);
        string result;
        for(auto num:nums){
    
    
            result+=to_string(num);
        }
        
        return result;
    }
};

剑指 Offer 46. 把数字翻译成字符串

使用动态规划
感觉这道题也可以用回溯里面的分割来做，每一层的节点值代表本次分割的情况，比如1223，第一层可以是1或者12

class Solution {
    
    
public:
    int translateNum(int num) {
    
    
        string str=to_string(num);
        int size=str.size();
        if(size<=1) return size;
        vector<int> dp(size+1,0);//dp[i]表示i个数字有多少种翻译方法
        dp[0]=1;
        dp[1]=1;
        for(int i=2;i<=size;i++){
    
    
            string s="";
            s+=str[i-2];
            s+=str[i-1];
  
            int k=stoi(s);
            if(k>=10&&k<=25){
    
    //两个条件都必须有，因为可能是06之类的
                dp[i]=dp[i-1]+dp[i-2];
            }
            else{
    
    
                dp[i]=dp[i-1];//第i位的数字和i-1位数字的分割方法进行组合
            }
        }
        return dp[size];
    }
};

剑指 Offer 47. 礼物的最大价值

class Solution {
    
    
public:
    int maxValue(vector<vector<int>>& grid) {
    
    
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>> dp(m,vector<int>(n,0));//[i,j]位置的最大值
        for(int i=0;i<n;i++){
    
    
            if(i==0) dp[0][0]=grid[0][0];
            else{
    
    
                dp[0][i]=dp[0][i-1]+grid[0][i];
            }
        }
        for(int i=1;i<m;i++){
    
    
            dp[i][0]=dp[i-1][0]+grid[i][0];
        }
        for(int i=1;i<m;i++){
    
    
            for(int j=1;j<n;j++){
    
    
                dp[i][j]=max(dp[i-1][j]+grid[i][j],dp[i][j-1]+grid[i][j]);
            }
        }
        return dp[m-1][n-1];
    }
};

剑指 Offer 48. 最长不含重复字符的子字符串

使用动态规划+哈希表完成

class Solution {
    
    
public:
    int lengthOfLongestSubstring(string s) {
    
    
        if(s.size()<=1) return s.size();
        unordered_map<char,int> m;//key记录最长子字符串的字符，value记录对应的字符在s中的下标位置
        vector<int> dp(s.size(),1);//dp[i]:字符串的最长子字符串以第i个字符结尾的
        m.insert(pair<char,int>(s[0],0));
        int start=0;//最长子字符串的长度的开始位置
        int max=0;//最长子字符串的长度
        for(int i=1;i<dp.size();i++){
    
    
            auto it=m.find(s[i]);
            if(it==m.end()){
    
    
                //说明不重复
                m.insert(pair<char,int>(s[i],i));
                dp[i]=dp[i-1]+1;
               
            }
            else{
    
    
                int index=it->second;//重复的下标位置
                for(int j=start;j<=index;j++){
    
    
                    m.erase(s[j]);//删掉哈希表重复位置之前的所有元素
                }
                m.insert(pair<char,int>(s[i],i));
                dp[i]=i-index;//从index后一位算起
                start=index+1;//更新开始位置
            }
            if(dp[i]>max) max=dp[i];
        }
        return max;

    }
};

剑指 Offer 49. 丑数

使用动态规划和三指针
这里需要注意下去重的问题，如果某次寻找丑数，找到了下一个丑数10，则pointer2和pointer5都需要加一，因为5乘2等于10， 5乘2也等于10，这样可以确保10只被数一次。

代码里面是用的三个并行的if操作，所以包含去重操作了

class Solution {
    
    
public:
    int nthUglyNumber(int n) {
    
    
        //丑数*质因子可以得到丑数
        vector<int> dp(n+1,1);
        int p1=1,p2=1,p3=1;//三个指针分别代表*2、*3、*5操作，如果某个操作被用过了，那么就将该指针+1
        for(int i=2;i<dp.size();i++){
    
    
            int val=min(min(2*dp[p1],3*dp[p2]),5*dp[p3]);
            if(val==2*dp[p1]) p1++;
            if(val==3*dp[p2]) p2++;
            if(val==5*dp[p3]) p3++;
            dp[i]=val;

        }
        return dp[n];
    }
};

剑指 Offer 50. 第一个只出现一次的字符

class Solution {
    
    
public:
    char firstUniqChar(string s) {
    
    
        if(s.size()==0) return ' ';
        unordered_map<char,int> m;
        
        for(int i=0;i<s.size();i++){
    
    
            m[s[i]]++;
        }
        for(int i=0;i<s.size();i++){
    
    
            if(m[s[i]]==1){
    
    
                return s[i];
            }
        }
        return ' ';
    }
};

剑指 Offer 52. 两个链表的第一个公共节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
    
    
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
    
    
        ListNode* node1=headA;
        ListNode* node2=headB;
        int size_A=0;
        int size_B=0;
        //算出两个链表的长度
        while(node1){
    
    
            size_A++;
            node1=node1->next;
        }
        while(node2){
    
    
            size_B++;
            node2=node2->next;
        }
        //对两个链表进行尾对齐
        int path=abs(size_A-size_B);
        node1=headA;
        node2=headB;
        if(size_A>size_B){
    
    
            
            while(path--){
    
    
                node1=node1->next;
            }
            while(node1&&node2){
    
    
                if(node1==node2) return node1;
                node1=node1->next;
                node2=node2->next;
            }
        }
        else{
    
    
            while(path--){
    
    
                node2=node2->next;
            }
            while(node1&&node2){
    
    
                if(node1==node2) return node1;
                node1=node1->next;
                node2=node2->next;
            }                
            
        }

        return NULL;//没找到返回NULL
    }
};

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

class Solution {
    
    
public:
    int search(vector<int>& nums, int target) {
    
    
        int result=0;
        for(int i=0;i<nums.size();i++){
    
    
            if(nums[i]==target){
    
    
                result++;
            }
        }
        return result;
    }
};

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

class Solution {
    
    
public:
    int missingNumber(vector<int>& nums) {
    
    
        int result=0;
        vector<int> vec(nums.size()+1,0);
        for(int i=0;i<nums.size();i++){
    
    
            vec[nums[i]]=1;
        }
        for(int i=0;i<vec.size();i++){
    
    
            if(vec[i]==0){
    
    
               result=i; 
               break;
            }
        }
        return result;
    }
};

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

/*
// 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:
    vector<Node*> vec;//存放中序遍历结果
    void mid_look(Node* node){
    
    
        //中序遍历的结果就是按照节点值从小到大的顺序
        if(node==NULL){
    
    
            return;
        }
        
        mid_look(node->left); 
        vec.push_back(node);
        mid_look(node->right);
        
    }
    Node* treeToDoublyList(Node* root) {
    
    
        if(root==NULL) return NULL;
        mid_look(root);
        for(int i=0;i<vec.size()-1;i++){
    
    
            Node* node=vec[i];
            Node* next=vec[i+1];
            node->right=next;
            next->left=node;
        }
        vec[vec.size()-1]->right=vec[0];
        vec[0]->left=vec[vec.size()-1];

        return vec[0];
    }
};

剑指 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 result=0;
    void max_depth(TreeNode* root,int depth){
    
    
        if(root==NULL){
    
    
            if(depth>result) result=depth;
            return;
        }
        max_depth(root->left,depth+1);
        max_depth(root->right,depth+1);

    }
    int maxDepth(TreeNode* root) {
    
    
        max_depth(root,0);
        return result;
    }
};

剑指 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:
    int max_depth=0;
    void is_banlanced(TreeNode* root,int depth){
    
    
        //递归遍历计算树的深度
        if(root==NULL){
    
    
            if(max_depth<depth) max_depth=depth;
            return;
        }
        is_banlanced(root->left,depth+1);
        is_banlanced(root->right,depth+1);


    }

    bool isBalanced(TreeNode* root) {
    
    
        if(root==NULL) return true;
        bool label1=true;//左子树是否为平衡二叉树的标志位
        bool label2=true;//右子树是否为平衡二叉树的标志位
        if(root->left) label1=isBalanced(root->left);
        if(root->right) label2=isBalanced(root->right);
        
        max_depth=0;
        is_banlanced(root->right,0);
        int depth_right=max_depth;//右子树的深度

        max_depth=0;
        is_banlanced(root->left,0);
        int depth_left=max_depth;//左子树的深度

        //若当前节点左右子树的深度相差超过1
        if(abs(depth_left-depth_right)>1) return false;

        //只有当前节点、当前节点的左右子树都符合要求时才会返回true
        return label1&&label2;
    }
};

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

法一：暴力解法+判断。超时
两层for循环 O（n^2)

class Solution {
    
    
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
    
   
        vector<int> result;
        if(nums.size()<=1) return result;

        for(int i=0;i<nums.size();i++){
    
    
            if(nums[i]>target) break;
            for(int j=i+1;j<nums.size();j++){
    
    
                if(nums[i]+nums[j]>target) break;
                if(nums[i]+nums[j]==target){
    
    
                    result.push_back(nums[i]);
                    result.push_back(nums[j]);
                    return result;
                }
            }
        }
        return result;
    }
};

法二：
时间复杂度O（n)

class Solution {
    
    
public:
    vector<int> twoSum(vector<int>& nums, int target) {
    
    
        vector<int> result;
        if(nums.size()<=1) return result;
        int i=0,j=nums.size()-1;//使用双指针从头尾开始逼近
        
        for(;i>=0&&j<nums.size()&&i<j;){
    
    
            int sum=nums[i]+nums[j];
            if(sum>target){
    
    
                j--;
                continue;
            }
            else if(sum<target){
    
    
                i++;
                continue;
            }
            else{
    
    
                result.push_back(nums[i]);
                result.push_back(nums[j]);
                break;
            }
        }
        return result;
    }
};

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

这道题虽然是简单题，但是需要注意考虑全是空格的情况

class Solution {
    
    
public:
    string reverseWords(string s) {
    
    
        // if(s.size()==0) return s;//记得判断特殊情况
        string result="";
        vector<string> vec;
        reverse(s.begin(),s.end());
        //“去掉”前后空格
        int i=0;
        for(;i<s.size();i++){
    
    
            if(s[i]!=' '){
    
    
                break;
            }
        }
        if(i==s.size()) return "";//去除全是空格的情况
        int j=s.size()-1;
        while(s[j]==' '){
    
    
            j--;
        }

        string str="";
        for(int k=i;k<=j;){
    
    
            if(s[k]!=' '){
    
    
                str.push_back(s[k]);
                k++;
            }
            else{
    
    //遇到空格就放入单词
                reverse(str.begin(),str.end());
                vec.push_back(str);
                while(s[k]==' ') k++;
                str="";
            }
        }
        reverse(str.begin(),str.end());
        vec.push_back(str);
        for(int i=0;i<vec.size();i++){
    
    
            result+=vec[i];
            if(i!=vec.size()-1) result+=" ";
        }
        return result;
    }
};

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

class MaxQueue {
    
    
public:
    queue<int> que;
    map<int,int,greater<int>> m;//按照key的值从大到小排序
    MaxQueue() {
    
    

    }
    
    int max_value() {
    
    
        if(que.size()==0) return -1;
        auto it=m.begin();
        int max_num=0;
        for(;it!=m.end();it++){
    
    
            if(it->second>0){
    
    
                max_num=it->first;
                break;
            }
        }
        return max_num;
    }
    
    void push_back(int value) {
    
    
        que.push(value);
        m[value]++;
    }
    
    int pop_front() {
    
    
        if(que.size()==0) return -1;
        m[que.front()]--;
        int val=que.front();
        que.pop();
        return val;
    }
};

/**
 * 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();
 */

剑指 Offer 60. n个骰子的点数

剑指 Offer 61. 扑克牌中的顺子

class Solution {
    
    
public:
    bool isStraight(vector<int>& nums) {
    
    
        //0相当于是癞子
        int num_zero=0;
        sort(nums.begin(),nums.end());
        int i=0;
        for(;i<nums.size();i++){
    
    
            if(nums[i]==0) num_zero++;
            else{
    
    
                break;
            }
        }
        int gap=0;
        for(;i<nums.size()-1;i++){
    
    
            if(nums[i]==nums[i+1]) return false;
            if(nums[i+1]-nums[i]>1) gap+=(nums[i+1]-nums[i]-1);//其他数之间的空隙
        }
        if(num_zero>=gap) return true;
        return false;
    }
};

剑指 Offer 63. 股票的最大利润

如果一旦出现加上某天相比前一天卖出的利润小于0，那么就重新开始计算

class Solution {
    
    
public:
    int maxProfit(vector<int>& prices) {
    
    
        int result=0;
        int max=0;
        for(int i=1;i<prices.size();i++){
    
    
            result+=prices[i]-prices[i-1];
            if(result<0){
    
    
                result=0;
                
            }
            else{
    
    
                if(result>max) max=result;
            }
        }
        return max;
    }
};

剑指 Offer 64. 求1+2+…+n

这道题其实就是在提示用递归的方法做

class Solution {
    
    
public:
    int sum=0;
    void sum_num(int n){
    
    
        if(n==0) return;
        sum+=n;
        sum_num(n-1);
        
    }
    int sumNums(int n) {
    
    
        sum_num(n);
        return sum;
    }
};

剑指 Offer 67. 把字符串转换成整数

class Solution {
    
    
public:
    int strToInt(string str) {
    
    
        //分情况进行讨论
        int result=0;
        int i=0;
        for(;i<str.size();i++){
    
    
            if(str[i]!=' '){
    
    
                break;
            }
        }
        if(i==str.size()) return 0;//字符串为空
        int j=i;
        long int num=0;
        if(str[i]=='-'){
    
    
            int a=0;
            for(j=i+1;j<str.size();j++){
    
    
                if(isdigit(str[j])){
    
    

                    num=num*10+str[j]-'0';
                    if(-num<INT_MIN) return INT_MIN;
                }
                else break;
            }
            num=-num;
            if(num<INT_MIN){
    
    
                result=INT_MIN;
            }
            else result=num;
        }
        if(str[i]=='+'){
    
    
            int a=0;
            for(j=i+1;j<str.size();j++){
    
    
                if(str[j]>='0'&&str[j]<='9'){
    
    
                    a=str[j]-'0';
                    num=num*10+a;  
                    if(num>INT_MAX) return INT_MAX;                  
                }
                else break;
            }
          
           result=num;
        }
        if('0'<=str[i]<='9'){
    
    
        // if(str[i]<='9'&&str[i]>='0'){
    
    
            int a=0;
            for(j=i;j<str.size();j++){
    
    
                if(str[j]>='0'&&str[j]<='9'){
    
    
                    a=str[j]-'0';
                    num=num*10+a;   
                    if(num>INT_MAX) return INT_MAX;                  
                }
                else break;
            }
            result=num;
        }
        return result;

    }
};

剑指 Offer 68 - 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:

    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
    
    
       if(root==q||root==p||root==NULL||(root->val<p->val&&root->val>q->val)||(root->val>p->val&&root->val<q->val)){
    
    
           return root;
       }
       TreeNode* node;
       if(root->val<q->val&&root->val<p->val) node=lowestCommonAncestor(root->right,p,q);
       if(root->val>q->val&&root->val>p->val) node=lowestCommonAncestor(root->left,p,q);
       return node;
        
    }
};

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

使用递归遍历，使用前序遍历进行搜寻，如果left和right只有一个为空，说明这两个节点再同一边，其中一个节点为公共祖先；如果两个都为空，说明没找到；如果两个都不为空，说明此时的节点就是最近公共祖先

/**
 * 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==p||root==q||root==NULL){
    
    
            return root;
        }

        TreeNode* left=lowestCommonAncestor(root->left,p,q);
        TreeNode* right=lowestCommonAncestor(root->right,p,q);

        if(left==NULL&&right==NULL) return NULL;
        else if(left==NULL) return right;
        else if(right==NULL) return left;
        else return root;
       

    }
};

猜你喜欢

转载自blog.csdn.net/qq_43050258/article/details/130233438
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
laravle中orm简单的增删改查
文本分类 特征选取之CHI开方检验
Spark核心编程-WordCount
大数据开发实战系列之电信客服(1)
读书笔记 - 把时间当作朋友 by 李笑来
python 笔记--if else
SpringBoot/Mybatis/Druid, 多数据源MultiDataSource配置思路
排序三个整数
redis集群搭建【2】-Windows中Redis集群搭建
STM32F030驱动TM1650点亮4联数码管
每日归档
更多
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022