剑指offer保姆级题解全集—C/C++版

最新推荐文章于 2024-08-05 14:46:49 发布
最新推荐文章于 2024-08-05 14:46:49 发布
阅读量5.3k 收藏 124
点赞数 47
分类专栏： 剑指offer 文章标签： 剑指offer习题全解 图文详解
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ych9527/article/details/117324385
版权

文章目录

前言

剑指offer作为经典算法题、在面试中遇到的几率非常之高，赶紧行动起来。

下次学妹，啊呸，面试官，再问你剑指offer直接一番天秀。
在这里插入图片描述

数组中重复的数字

找出数组中重复的数字。在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

题目链接

方法1：

sort排序后，遍历数组，前面的值和后面的值相等即可

时间复杂度：nongn；

空间复杂度：快排需要递归，栈桢消耗 longn

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int count=0;
        for(int i=0;i<nums.size()-1;i++)
        {
            if(nums[i]==nums[i+1])
            {
                count=nums[i];
                break;
            }
        }
        return count;


    }
};

方法2：

统计排序、找出统计数组之中，值大于1的选项，然后+1返回

时间复杂度：O(n);

空间复杂度： O(n)；

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        vector<int> ret(nums.size(),0);
        for(auto &e:nums)
        {
            if(ret[e]!=0)
            return e;
            ret[e]++;
        }
        return 0;

    }
};

二维数组中的查找

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

题目链接

image-20210505133456920

时间复杂度：O(m*n)

空间复杂度：O(1)

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) { 
        if(matrix.size()==0)
        return false;
        
        int row=0;
        int col=matrix[0].size()-1;

        while(row>=0&&row<matrix.size()&&col>=0&&col<matrix[0].size())
        {
            if(matrix[row][col]>target)
                col--;
            else if(matrix[row][col]<target)
                row++;
            else
                return true;
        }
        return false;

    }
};

替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

题目链接

遍历s，遇到空格，则str+=“%20”，其余情况之下，+=s[i]

【注意：先开辟好str的空间，避免发生增容，导致发生拷贝】

时间复杂度:O(n)

空间复杂度:O(n)

class Solution {
public:
    string replaceSpace(string s) {
        string str;
        str.reserve(s.size());
        for(int i=0;i<s.size();i++)
        {
            if(s[i]==' ')
            str+="%20";
            else
            str+=s[i];
        }
        return str;

    }
};

从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

题目链接

方法1：递归

链表天然具有递归属性

时间复杂度：O(N) 遍历整个链表

空间复杂度： O(N) 栈桢消耗n，返回数组n

class Solution {
public:
    void _reversePrint(ListNode* head,vector<int> &ret)
    {
        if(head==NULL)
        return ;

        _reversePrint(head->next,ret);
        ret.push_back(head->val);
    }
    vector<int> reversePrint(ListNode* head) {
        vector<int> ret;
        _reversePrint(head,ret);
        return ret;
    }
};

方法2：遍历reverse

遍历链表，将所有的内容添加至数组之中

然后将数组逆转

时间复杂度： O(N) 遍历整个链表

空间复杂度：O(N) 返回数组消耗

class Solution {
public:
    vector<int> reversePrint(ListNode* head) {
        vector<int> ret;
       ListNode* cur=head;
        while(cur)
        {
            ret.push_back(cur->val);
            cur=cur->next;
        }
        reverse(ret.begin(),ret.end());
        return ret;
 
    }
};

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

题目链接

中序之中寻找该根节点的位置，然后在中序之中判断该节点是否还有左右子树

时间复杂度：O(N^2)：需要每次需要在中序之中遍历寻找根节点的位置

空间复杂度：O(N) 开辟N个节点空间、递归深度O(N)

image-20210527105546315

class Solution {
public:
    TreeNode* _buildTree(vector<int>& preorder, vector<int>& inorder,int &prev,int &inor_begin,int &inor_end)
    {
        if(prev>=preorder.size()||inor_begin>inor_end)
            return NULL;
        
        TreeNode *root=new TreeNode(preorder[prev]);//构造根节点

        int start=inor_begin;
        while(start<inor_end)
        {
            if(inorder[start]==preorder[prev])
                break;
            start++;
        }

        int end=start-1;
        if(inor_begin<=end)//还有左区间
            root->left= _buildTree(preorder,inorder,++prev,inor_begin,end);
        else
            root->left=NULL;

        int begin=start+1;
        if(begin<=inor_end)//还有右区间
            root->right=_buildTree(preorder,inorder,++prev,begin,inor_end);
        else    
            root->right=NULL;
        
        return root;
        
    } 

    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        //在前序中找根节点、找到后去中序遍历中找左右子树

        int prev=0;
        int inor_begin=0;
        int inor_end=inorder.size()-1;

        return _buildTree(preorder,inorder,prev,inor_begin,inor_end);
    }
};

用栈实现两个队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

题目链接

定义两个栈 -> st1、st2

入数据入到栈st1,当需要出数据的时候判断st2是否为空，不为空则直接从st2之中出

为空则将st1的全部内容倒过来，然后再出数据

class CQueue {
public:
    CQueue() {}//自定义类型、自动调用构造函数
    
    void appendTail(int value) {
        st1.push(value);
    }
    
    int deleteHead() {
        if(st2.empty())
        {
            while(!st1.empty())
            {
                st2.push(st1.top());
                st1.pop();
            }
        }
        if(st2.empty())
        return -1;
        
        int val=st2.top();
        st2.pop();
        return val;
    }

    stack<int> st1;
    stack<int> st2;
};

斐波那契数列

题目链接

方法1：递归法(超时)

方法2：三指针迭代法（first=1、second=0、third=0）

时间复杂度 ：O(N)

空间复杂度：O(1)

class Solution {
public:
    int fib(int n) {

        int first=1;
        int second=0;
        int third=0;

        for(int i=0;i<n;i++)
        {
            third=(first+second)%1000000007;
            first=second;
            second=third;
        }
        return third;

    }
};

青蛙跳台阶

一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 n 级的台阶总共有多少种跳法。答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

题目链接

将题目转换一下就是： 1 1 2 3 5 斐波那契数列的斐波那契数列

class Solution {
public:
    int numWays(int n) {
        // 1 1 2 3 5 斐波那契数列

        int first=0;
        int second=1;
        int third=1;

        for(int i=0;i<n;i++)
        {
            third=(second+first)%1000000007;
            first=second;
            second=third;
        }
        return third;
    }
};

旋转数组的最小数字

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。

题目链接

image-20210505165624842

class Solution {
public:
    int minArray(vector<int>& numbers) {
        int left=0;
        int right=numbers.size()-1;

        while(left<right)
        {
            int mid=left+(right-left)/2;
            
            if(numbers[mid]>numbers[right])
                left=mid+1;
            else if(numbers[mid]<numbers[right])
                right=mid;
            else//相等时
                right--;
        }
        return numbers[left];
    }
};

矩阵的路径

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

题目链接

深度搜索、回溯法：遍历搜索二维数组，找到第一个头节点之后，传入递归搜索函数，往四个方向进行搜索

image-20210505154849105

机器人运动范围

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

题目链接

机器人坐标统计：sum=i%10+i/10+j%10+j/10;（n、m都是大于小101的，即i和j最高是两位数、为横坐标、j为纵坐标）

要想到达一个格子：那么 当前坐标和sum<=k&&有方向可以过来

因此可以建立一个二维数组、全部初始化为false，（0,0,）->true

得到转移方程 dp[i][j]=(dp[i-1] [j]||dp[i+1] [j]|| dp[i] [j-1] || dp[i] [j+1])&&sum<=k

又是从左往右、从上之下进行遍历，因此只需要判断左边和上边的格子是否能够过来即可

class Solution {
public:
    int movingCount(int m, int n, int k) {

    vector<vector<bool>>ret(m,vector<bool>(n,false));
    ret[0][0]=true;
    int count=1;
    
    for(int i=0;i<m;i++)
    {
        for(int j=0;j<n;j++)
        {
            int sum=i%10+i/10+j%10+j/10;//统计坐标和
                //K满足条件，还需要判断四周是否有可以过来的格子
        if(((i>0&&ret[i-1][j])||(j>0&&ret[i][j-1]))&&sum<=k)//判断是否可以从上面或者左边过来&&sum<=k
            {
                ret[i][j]=true;
               count++;
            }
        }
    }
    return count;
    }
};

空间优化：

由上述可知，当前坐标只与上边和左边的格子有关系，因此可以用一个滚动数组来进行优化

class Solution {
public:
    int movingCount(int m, int n, int k) {
        vector<bool> ret(n,false);
        ret[0]=true;
        int count=1;

        for(int i=0;i<m;i++)
        {
            for(int j=0;j<n;j++)
            {
                if(i==0&&j==0)
                continue;
                int sum=i%10+i/10+j%10+j/10;//坐标和

                if(sum<=k&&((j>0&&ret[j-1])||ret[j]))
                    {
                        ret[j]=true;
                        count++;
                    }
                else
                    ret[j]=false;//滚动数组、当sum不满足条件时，需要重新赋值
            }
        }
        return count;
    }
};

回溯法：

class Solution {
public:
    void _movingCount(vector<vector<bool>> &ret,int m, int n, int k,int &count)
    {
       if(m>=ret.size()||n>=ret[0].size())//坐标越界
        return ;

        if(ret[m][n]==true&&(m!=0||n!=0))
        return;

        int sum=m%10+m/10+n%10+n/10;//坐标和

        if(sum>k)//当前肯定进不来
        return;

        if(sum<=k&&((m>0&&ret[m-1][n])||(n>0&&ret[m][n-1])))
        {
            ret[m][n]=true;
            count++;
        }

        //往右下走
        _movingCount(ret,m,n+1,k,count);
        _movingCount(ret,m+1,n,k,count);
    }

    int movingCount(int m, int n, int k) {
        vector<vector<bool>> ret(m,vector<bool>(n,false));
        ret[0][0]=true;
        int count=1;
        _movingCount(ret,0,0,k,count);

        return count;
    }
};

减绳子

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m-1] 。请问 k[0]k[1]…*k[m-1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
题目链接

任何一个大于4的自然数都可分解成2、3的组合 -> 要想乘积最大就需要3的数量最多

class Solution {
public:
    int cuttingRope(int n) {
    //最少分成2端段
    if(n==2)
    return 1;
    if(n==3)
    return 2;
    
    int count=1;
      while(n>4)//小于5的数不可以被分解为2和3
      {
          count*=3;
          n-=3;
      }
      if(n!=0)
      count*=n;
      return count;
    }
};

剪绳子 II

给你一根长度为 n 的绳子，请把绳子剪成整数长度的 m 段（m、n都是整数，n>1并且m>1），每段绳子的长度记为 k[0],k[1]…k[m - 1] 。请问 k[0]k[1]…*k[m - 1] 可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
题目链接

和上题的解题思路是一样的，不过需要注意返回值越界的问题

class Solution {
public:
    int cuttingRope(int n) {
    //最少分成2端段
    if(n==2)
    return 1;
    if(n==3)
    return 2;
    
    long long count=1;//用 longlong防止越界
      while(n>4)//小于5的数不可以被分解为2和3
      {
          count*=3;
          n-=3;
          count%=1000000007;
      }
      if(n!=0)
      count*=n;
      
      return (int)(count%1000000007);//返回值结果再取余、强转
    }
};

二进制中1的个数

请实现一个函数，输入一个整数（以二进制串形式），输出该数二进制表示中 1 的个数。例如，把 9 表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
题目链接

n&(n-1) -> 每次减少一个1

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int count=0;
        while(n)
        {
            n&=(n-1);
            count++;
        }
        return count;
        
    }
};

数值的整数次方

实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，x^n）。不得使用库函数，同时不需要考虑大数问题。
题目链接

利用大幂数计算

时间复杂度：O(logn）每次指数减少一半

在这里插入图片描述

class Solution {
public:
    double myPow(double x, int n) {
        long long index=n;//防止n转正数的时候越界
        if(n<0)
        {
            x=1/x;
            index*=-1;;
        }
        double ret=1;
        while(index)
        {
            if(index&1==1)
            ret*=x;

            //指数右移动一位，缩小两倍 -> 基数^2
            index>>=1;
            x*=x;
        }

        return  ret;
    }
};

打印从1到最大的n位数

输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
题目链接

由题可知：数字是从 1 -> pow(10,n)-1;

class Solution {
public:
    vector<int> printNumbers(int n) {
        vector<int> ret(pow(10,n)-1);
        for(int i=1;i<pow(10,n);i++)
        {
            ret[i-1]=i;
        }
        return ret;
    }
};

删除链表的节点

给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。返回删除后的链表的头节点。
题目链接

定义两个前后两个指针，遍历链表，找到后断开点前链接

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        if(head==NULL)
        return head;
        if(head->val==val)//头结点即是
        return head->next;

        ListNode *prev=NULL;
        ListNode *cur=head;

        while(cur)
        {
            if(cur->val==val)
            prev->next=cur->next;

            prev=cur;
            cur=cur->next;
        }
        return head;
    }
};

表示数值的字符串

请实现一个函数用来判断字符串是否表示数值（包括整数和小数）
题目链接

字符串分为：

整数 . 小数

e出现在整数部分、并且e后面不能有小数点、并且e后面可以跟一个符号、并且e后面必须有数字

class Solution {
public:
    bool isNumber(string s) {
        //一个数 = 整数 + 小数
        // 先整数部分进行操作 -> 去除前导空格、去除符号
        //去除完毕之后、判断是否有整数部分 -> 如果遇到点，则需要判断后面是否有数字(现在还是去除前缀阶段)
        //前缀处理完毕，来到后序的处理
        //如果遇到点，判断是第几次出现&&点的前面不能出现e
        //如果遇到e，e后面可以有一个符号位，并且符号位后面必须有一位数字

        int sub=0;
        int size=s.size();
        while(sub<size&&s[sub]==' ')
        {
            sub++;//去除前缀空格
        }

        if(sub<size&&(s[sub]=='+'||s[sub]=='-'))
            sub++;//去除符号
        
        //上述过程、前缀整数部分处理完毕

        int flag=0;//记录点的个数
        if(sub<size&&s[sub]=='.')
        {
            sub++;
            flag=1;
        }

        if(flag==1&&(sub>=size||(!(s[sub]>='0'&&s[sub]<='9'))))
            return false;//.后面没有数字
        
        int _e=0;//记录e的出现次数、
        if(sub>=size||s[sub]=='e'||s[sub]=='E')
            return false;//e不能出现在前面

        while(sub<size)
        {
            if(s[sub]=='.')
            {
                if(flag>0)//多次出现
                    return false;
                if(_e!=0)//前面出现了e
                    return false;
                else
                    flag++;
            }
            else if(s[sub]=='e'||s[sub]=='E')//出现e
            {
                if(_e>0)//只可出现一次
                    return false;
                if(++sub>=size)//e后面必须由数字
                    return false;
                if(s[sub]=='+'||s[sub]=='-')
                    sub++;//去除符号位
                if(sub>=size||(!(s[sub]>='0'&&s[sub]<='9')))
                    return false;//不是数字
                _e++;
            }
            else if(s[sub]==' ')//遇到末端空格
            {
                while(sub<size)
                {
                    if(s[sub]==' ')
                        sub++;
                    else
                        break;
                }
                if(sub<size)
                    return false;//遇到空格并不是结尾
                else
                    return true;
            }
            else
            {
                if(!(s[sub]>='0'&&s[sub]<='9'))
                    return false;//遇到的不是数字
            }
            sub++;//下标后移
        }
        
        return true;

        

    }
};

调整数组顺序使奇数位于偶数前面

输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
题目链接

利用快排之中的双指法，进行交换

class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int left=0;
        int right=nums.size()-1;

        while(left<right)
        {
            while(left<right&&nums[right]%2==0)
                right--;
            while(left<right&&nums[left]%2==1)
                left++;
            
            if(left<right)
                swap(nums[left],nums[right]);
        }
        return nums;
    }
};

链表中倒数第k个节点

输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
题目链接

快慢指针：快指针先走k步，然后慢指针再出发，快指针为空时，就是倒数第K个节点

class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        if(head==NULL)
            return head;

        ListNode *cur=head;
        ListNode *next=head;
        while(k)
        {
            next=next->next;
            k--;
        }

        while(next)
        {
            cur=cur->next;
            next=next->next;
        }

        return cur;
    }
};

反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

题目链接

递归法

image-20210517211515320

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL)
            return head;
        
        ListNode *newhead=reverseList(head->next);
        head->next->next=head;
        head->next=NULL;
        return newhead;
    }
};

迭代法

image-20210517212315218

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if(head==NULL||head->next==NULL)
            return head;

        ListNode* prev=NULL;
        ListNode* cur=head;
        ListNode* next=cur->next;
        while(cur)
        {
            cur->next=prev;
            prev=cur;
            cur=next;
            if(next)
                next=next->next;
        }
        return prev;
    }
};

合并两个排序链表

输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。
题目链接
image-20210517213603971

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode *cur1=l1;
        ListNode *cur2=l2;

        ListNode *newhead=new ListNode;
        ListNode *ret=newhead;
        while(cur1&&cur2)
        {
            if(cur1->val<cur2->val)
            {
                newhead->next=cur1;
                cur1=cur1->next;
            }
            else 
            {
                newhead->next=cur2;
                cur2=cur2->next;
            }
            newhead=newhead->next;
        }
        if(cur1)
            newhead->next=cur1;
        else
            newhead->next=cur2;

        return ret->next;
    }
};

树的子结构

题目链接

输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)，B是A的子结构， 即 A中有出现和B相同的结构和节点值。

此处需要连个个递归，一个递归遍历树A，以树A任意一个节点为根节，判断是否与树B相等。 ->递归条件，当树B为空时，返回false，题目规定空树不是任何树的子树。

当A为空时，返回false，表示当前的树A已经走完了，但是还没有找到对应B的子结构，此时说明B不是A的子结构。

另外一个递归则判断，以当前的A的一个节点为根节点的树，是否和树B相等

这里的递归出口是，如果B树不为空，A树为空，说明A中没有B的节点，返回false。

如果B树为空，说明全部找到了返回false。

最后的返回是，左&&右子&&当前节点对应的值是否相等

class Solution {
public:
    bool _isSubStructure(TreeNode *A,TreeNode*B)
    {
        if(A==NULL&&B!=NULL)
            return false;
        if(B==NULL)
            return true;
        if(A->val!=B->val)
            return false;
       return  _isSubStructure(A->left,B->left)&&_isSubStructure(A->right,B->right);
    }
    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if(A==NULL||B==NULL)//遍历完了，还未找到对应结构
            return false;
        if(_isSubStructure(A,B))//如果有找到的
            return true;
        
        return isSubStructure(A->left,B)||isSubStructure(A->right,B);//递归遍历
    }
};

二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

题目链接

image-20210518073914449

class Solution {
public:
    void _mirrorTree(TreeNode *root)
    {
        if(root==NULL)
            return ;
        swap(root->left,root->right);
        _mirrorTree(root->left);
        _mirrorTree(root->right);
    }
    TreeNode* mirrorTree(TreeNode* root) {
        _mirrorTree(root);
        return root;
    }
};

对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

题目链接

image-20210518074937842

class Solution {
public:
    bool _isSymmetric(TreeNode* root1,TreeNode* root2)
    {
        if(root1==NULL&&root2==NULL)
            return true;
        if(root1==NULL||root2==NULL)//其中一个为空
            return false;
        return 
        (root1->val==root2->val)&&
        _isSymmetric(root1->left,root2->right)&&
        _isSymmetric(root1->right,root2->left);
    }
    bool isSymmetric(TreeNode* root) {
        if(root==NULL)
            return true;
        return _isSymmetric(root->left,root->right);
    }
};

​

顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

题目链接

image-20210518094102775

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> ret;
        if(matrix.size()==0)
            return ret;
        int left=0;
        int right=matrix[0].size()-1;
        int up=0;
        int down=matrix.size()-1;

        while(left<=right||up<=down)
        {
            while(up<=down)//从左至右
            {
                for(int i=left;i<=right;i++ )
                {
                    ret.push_back(matrix[up][i]);
                }
                up++;
                break;
            }
            while(left<=right)//从上之下
            {
                for(int i=up;i<=down;i++)
                {
                    ret.push_back(matrix[i][right]);
                }
                right--;
                break;
            }
            while(up<=down)//从右往左
            {
                for(int i=right;i>=left;i--)
                {
                    ret.push_back(matrix[down][i]);
                }
                down--;
                break;
            }
            while(left<=right)//从下至上
            {
                for(int i=down;i>=up;i--)
                {
                    ret.push_back(matrix[i][left]);
                }
                left++;
                break;
            }

        }
        return ret;
    }
};

包含min函数的栈

题目链接

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

image-20210519103809594

class MinStack {
public:
    /** initialize your data structure here. */
    MinStack() {
        //自动调用自定义成员的构造函数
    }
    
    void push(int x) {
        st1.push(x);

        if(st2.empty()||x<=st2.top())
            st2.push(x);
    }
    
    void pop() {
        if(st1.top()==st2.top())
            st2.pop();

        st1.pop();
    }
    
    int top() {
        return st1.top();
    }
    
    int min() {
        return st2.top();
    }
    stack<int> st1;
    stack<int> st2;
};

栈的压入弹出顺序

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。题目链接

image-20210519110751958

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        stack<int> st;

        int sub1=0;
        int sub2=0;

        while(sub1<pushed.size())
        {
            st.push(pushed[sub1++]);
            while(!st.empty()&&st.top()==popped[sub2])
            {
                sub2++;
                st.pop();
            }
        }
        if(st.empty())
            return true;
        return false;
    }
};

从上之下打印二叉树

给定一个队列和一个一维数组，将不为空的节点依次入队，取出来的时候再将对应的值填入一维数组之中

class Solution {
public:
    vector<int> levelOrder(TreeNode* root) {
        vector<int> ret;
        queue<TreeNode*>q;
        if(root)
            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;
    }
};

从上之下打印二叉树||

从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

题目链接

利用队列保存节点的同时，给定一个变量，保存每一层节点的数目

image-20210519120622924

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> ret;
        queue<TreeNode*> q;
        if(root)
            q.push(root);
        int count=1;

        vector<int> temp;
        while(!q.empty())
        {
            vector<int> temp;
            while(count--)//将当前层节点全部取出来
            {
                TreeNode* node=q.front();
                q.pop();
                temp.push_back(node->val);

                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            ret.push_back(temp);
            temp.clear();
            count=q.size();//更新下一层节点的数
        }

        return ret;
    }
};

从上至下打印二叉树|||

请实现一个函数按照之字形顺序打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。

题目链接

本题和上题本质上是一样的，只需要再给定一个变量，如果当前是奇数层，将当前层的数组逆转一下，再插入至返回数组中即可

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
         vector<vector<int>> ret;
        queue<TreeNode*> q;
        if(root)
            q.push(root);
        int count=1;
        int flag=0;

        vector<int> temp;
        while(!q.empty())
        {
            vector<int> temp;
            while(count--)//将当前层节点全部取出来
            {
                TreeNode* node=q.front();
                q.pop();
                temp.push_back(node->val);

                if(node->left)
                    q.push(node->left);
                if(node->right)
                    q.push(node->right);
            }
            if(flag%2==1)//为奇数则逆转
                reverse(temp.begin(),temp.end());

            ret.push_back(temp);
            temp.clear();
            count=q.size();//更新下一层节点的数
            flag++;
        }

        return ret;
    }
};

二叉树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。题目链接

image-20210520200637898

class Solution {
public:
    bool _verifyPostorder(vector<int>&postorder,int begin,int end)
    {
        if(begin>=end)//此时表明没有区间可以划分了 -> 返回true
            return true;
        
        int start=end;
        for(int i=begin;i<end;i++)
        {
            if(postorder[i]>postorder[end])
            {
                start=i;//得到右子树区间的起点
                break;
            }
        }
        for(int i=start+1;i<end;i++)
        {
            if(postorder[i]<postorder[end])//右子树全部大于根
                return false;
        }

        return 
        _verifyPostorder(postorder,begin,start-1)&&
        _verifyPostorder(postorder,start,end-1);
    }
    bool verifyPostorder(vector<int>& postorder) {
        return _verifyPostorder(postorder,0,postorder.size()-1);
    }
};

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

输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。题目链接

image-20210520202332454

class Solution {
public:
    void _pathSum(TreeNode*root,int target,vector<vector<int>>&ret,vector<int>&temp,int sum)
    {
        if(root==nullptr)
            return ;
        temp.push_back(root->val);//保存当前节点
        sum+=root->val;//当齐前路径和
        
        if(sum==target&&root->left==nullptr&&root->right==nullptr)//找到了一条路径
            ret.push_back(temp);
        
        _pathSum(root->left,target,ret,temp,sum);
        _pathSum(root->right,target,ret,temp,sum);

        temp.pop_back();//回溯,sum是临时变量，不需要回溯
    }
    vector<vector<int>> pathSum(TreeNode* root, int target) {
        vector<vector<int>>ret;
        vector<int>temp;
        _pathSum(root,target,ret,temp,0);
        return ret;
    }
};

复杂链表的赋值

请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。题目链接

方法1：

image-20210520203732603

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head==NULL)
            return NULL;
        Node *newhead=new Node(head->val);//新链表的头
        //两个链表的临时头
        Node *tnewhead=newhead;
        Node *thead=head->next;

        while(thead)//创建新链表
        {
            tnewhead->next=new Node(thead->val);
            thead=thead->next;
            tnewhead=tnewhead->next;
        }
        //至此新链表已经被完全创建出来了、接下来便是填入随机指针

    //回到起始位置
        tnewhead=newhead;
        thead=head;

    //寻找相对位置
        while(thead)
        {
            if(thead->random==NULL)//为空指针
                tnewhead->random=NULL;
            else//不为空指针
            {
                //从起始位置起
                Node *temph=head;
                Node *tempn=newhead;

                while(temph !=thead->random)
                {
                    temph=temph->next;
                    tempn=tempn->next;
                }
                //此时通过随机位置，找到了对应的random指针
                tnewhead->random=tempn;
            }
            thead=thead->next;
            tnewhead=tnewhead->next;
        }
        return newhead;
    }
};

方法2：

利用map进行解题

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(!head)
            return nullptr;

        map<Node*,Node*> list;
        Node *newhead=head;
        //构造map
        while(newhead)//构造新旧链表的map
        {
            Node *cur=new Node(newhead->val); 
            list.insert(make_pair(newhead,cur));//将节点插入map之中
            newhead=newhead->next;
        }

        //从map之中将拷贝的链表取出来
        newhead=head;
        Node *ret_node=new Node(0);
        Node *ret=ret_node;

        while(newhead)
        {
            ret_node->next=list[newhead];//将新链表链接起来
            ret_node=ret_node->next;

        //填入对应的random
            if(newhead->random==NULL)
                ret_node->random=NULL;
            else
                ret_node->random=list[newhead->random];
        //更新位置
            newhead=newhead->next;
        }

        return ret->next;
    }
};

二叉搜索树与双向链表

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

image-20210520213139389

class Solution {
public:
    void _treeToDoublyList(Node* root,Node* &prev)
    {
        if(root==NULL)
            return;

        _treeToDoublyList(root->left,prev);

        if(prev!=NULL)
            prev->right=root;
        root->left=prev;
        prev=root;//保存备份

        _treeToDoublyList(root->right,prev);
    }
    Node* treeToDoublyList(Node* root) {
        Node *head_left=root;
        Node *head_right=root;
        Node *prev=NULL;

        if(root==NULL)
            return root;
        while(head_left->left!=NULL)//找到最小节点
        {
            head_left=head_left->left;
        }
        while(head_right->right!=NULL)//找到最大节点
        {
            head_right=head_right->right;
        }
        
        _treeToDoublyList(root,prev);

        head_left->left=head_right;//左指向右
        head_right->right=head_left;//右指向左
        
        return head_left;
    }
};

字符串的排列序列

输入一个字符串，打印出该字符串中字符的所有排列。你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。

题目链接

image-20210521101435169

class Solution {
public:
    void _permutation(string&s,vector<string>&ret,string &temp,vector<bool>&flag)
    {
        if(temp.size()==s.size())
        {
            ret.push_back(temp);
            return;
        }
        for(int i=0;i<s.size();i++)
        {
            if(i-1>=0&&s[i]==s[i-1]&&flag[i-1]==true)//当前节点和前面节点相同，且前面的已经使用过了
                continue;

            if(flag[i]==false)//已经用过了
                continue;

            temp+=s[i];
            flag[i]=false;//进行标记
            
            _permutation(s,ret,temp,flag);
            
            //回溯
            flag[i]=true;
            temp.pop_back();
        }
    }

    vector<string> permutation(string s) {
        vector<string>ret;
        vector<bool>flag(s.size(),true);//标记数组
        string temp;
        sort(s.begin(),s.end());
        _permutation(s,ret,temp,flag);

        return ret;
    }
};

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

数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

题目链接

本题采用摩尔投票法：即用一个变量记录当前数字，获得的票数。遇到相同的则票数+1，不同的票数-1，当票数等于0的时候，更换数字

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        int num=nums[0];
        int count=0;

        for(auto&e:nums)
        {
            if(count==0)
            {
                count=1;
                num=e;
            }
            else
            {
                if(num==e)
                    count++;
                else
                    count--;
            }
        }
        return num;
    }
};

最小的k个数

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

题目链接

top K问题，找K个最小的数，建立一个K的大堆

class Solution {
public:
    vector<int> getLeastNumbers(vector<int>& arr, int k) {
        vector<int> ret;
        if(k==0)
            return ret;
        priority_queue<int,vector<int>,less<int>> heap;//建大堆,less为大堆
        
        for(auto&e:arr)
        {
            if(heap.size()<k)//小于K个直接入堆
                heap.push(e);
            else
            {
                if(e<heap.top())
                {
                    heap.pop();
                    heap.push(e);
                }
            }
        }

        while(!heap.empty())
        {
            ret.push_back(heap.top());
            heap.pop();
        }
        return ret;
    }
};

数据流中的中位数

如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。

题目链接

解法：

构建一个大堆，一个小堆。

小堆保存较大的那一半，堆顶的元素，是较大元素中的最小的一个

大堆保存较小的那一半，堆顶的元素，是较小元素中的最大的一个

同时还得保证，两个堆的元素相差不超过1，这样才能保证，两个堆将数据平分

注意点：

在元素入小堆的时候，需要判断当期元素是否大于大堆的堆顶，如果小于则和大堆堆顶进行“交换”

在元素入大堆的时候，需要判断当前元素是否小于小堆的堆顶，如果大于，则和小堆堆顶进行"交换"

-> 这两个判断保证了，将数组中元素平分，且小堆里面的所有元素大于大堆内的所有元素

class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder() {
    }
    void addNum(int num) {
        if(max_heap.empty())//先入大堆
            max_heap.push(num);
        else
        {
            if(min_heap.size()>max_heap.size())//小堆元素多、入大堆
                {
                    if(num>min_heap.top())//大于小堆的堆顶元素
                    {
                        //将新来的元素与小堆顶交换
                        int temp=min_heap.top();
                        min_heap.pop();
                        min_heap.push(num);
                        //将小堆顶的元素取下来放入大堆
                        max_heap.push(temp);
                    }
                    else//直接放入大堆
                        max_heap.push(num);
                }
            else if(min_heap.size()<max_heap.size())//大堆元素多,入小堆
            {
                if(num<max_heap.top())//新来的元素小于大堆堆顶的元素
                {
                    //将新来的元素与大碓顶交换
                    int temp=max_heap.top();
                    max_heap.pop();
                    max_heap.push(num);
                    //将大堆顶拿下的元素放入小堆
                    min_heap.push(temp);
                }
                else//直接入小堆
                    min_heap.push(num);
            }
            else//两堆元素一样多
            {
                if(num>max_heap.top())//小堆保存较大的那一半
                    min_heap.push(num);
                else
                    max_heap.push(num);
            }
        }
    }
    
    double findMedian() {
        if(min_heap.size()==max_heap.size())//各取一个
        {
            return min_heap.top()/2+max_heap.top()/2;
        }
        else//取一个即可
        {
            //谁多取谁
            if(min_heap.size()>max_heap.size())
                return min_heap.top();
            else
                return max_heap.top();
        }
    }

    priority_queue<double,vector<double>,greater<double>> min_heap;//小堆
    priority_queue<double,vector<double>,less<double>> max_heap;//大堆
};

简化写法：

当大小堆元素数量相等时，将元素插入大堆，然后将大堆顶的元素取出来，插入小堆 ->保证了小堆了元素比大堆大

当大小对元素数量不相等时，将元素插入小堆，然后将小堆顶的元素取出来，插入大堆 ->保证了大堆的所有元素比小堆小

class MedianFinder {
public:
    /** initialize your data structure here. */
    MedianFinder() 
    {}
    
    void addNum(int num) {
        if(min_heap.size()==max_heap.size())
        {
            max_heap.push(num);
            int temp=max_heap.top();
            max_heap.pop();
            min_heap.push(temp);
        }
        else
        {
            min_heap.push(num);
            int temp=min_heap.top();
            min_heap.pop();
            max_heap.push(temp);
        }
    }
    
    double findMedian() {
        if(min_heap.size()==max_heap.size())
            return min_heap.top()/2+max_heap.top()/2;
        else
            return min_heap.size()>max_heap.size()?min_heap.top():max_heap.top();
    }

    priority_queue<double,vector<double>,greater<double>> min_heap;//小堆
    priority_queue<double,vector<double>,less<double>> max_heap;//大堆
};

连续子数组的最大和

输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值，要求时间复杂度为O(n)。

题目链接

判断当前数对后面的数是否有"正贡献"，如果有则加到后面的数上面，如果没有则不加

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int max=nums[0];
        int size=nums.size();

        for(int i=0;i<size-1;i++)
        {
            if(nums[i]>0)//对后面的数有正贡献
                nums[i+1]+=nums[i];
            
            max=fmax(max,nums[i+1]);
        }
        return max;
    }
};

把数组排成最小数

输入一个非负整数数组，把数组里所有数字拼接起来排成一个数，打印能拼接出的所有数字中最小的一个。

题目链接

解法：

将字符串转成数组，然后写一个仿函数自定义比较负责，利用sort进行排序即可

规则：s1+s2与s2+s1进行比较

-> 两个字符串放在前后的位置，不同的放置方法得到的最终结果的大小是不一样的

->将数组转换成字符数组，然后再进行比较，即可得到最终的排列·

struct Less
{
    bool operator()(string s1,string s2)
    {
      return s1+s2<s2+s1;
    }
};
class Solution {
public:
    string minNumber(vector<int>& nums) {
        vector<string>arr;
        for(auto&e:nums)
            arr.push_back(to_string(e));
        
        sort(arr.begin(),arr.end(),Less());

        string ret;
        for(auto&e:arr)
        {
            ret+=e;
        }
        return ret;
    }
};

把数字翻译成字符串

给定一个数字，我们按照如下规则把它翻译为字符串：0 翻译成 “a” ，1 翻译成 “b”，……，11 翻译成 “l”，……，25 翻译成 “z”。一个数字可能有多个翻译。请编程实现一个函数，用来计算一个数字有多少种不同的翻译方法。

题目链接

解法：

1.将数组转成字符串->方便取数字

2.设dp[i]表示取第i为数字时构成的种类

3.很显然，当i-1与i构成的数字小于25的时候，和前面的构成一种方法，拆开也是一种方法 -> 转移方程：

当和前面的数字构成的数小于25时 -> dp[i]=dp[i-1]+dp[i-2]

否则 dp[i]=dp[i-1]

class Solution {
public:
    int translateNum(int num) {
        string str=to_string(num);

        vector<int>dp(str.size()+1,0);
        //dp[i]表示到数字的第i位时，解法的种类

        dp[0]=1;
        dp[1]=1;//只有一个字符时的翻译种类为1种
        for(int i=1;i<str.size();i++)
        {
            string temp;
            temp+=str[i-1];
            temp+=str[i];
            int nums=stoi(temp);
            if(str[i-1]!='0'&&nums<=25)//前导不为0
                dp[i+1]=dp[i]+dp[i-1];
            else
                dp[i+1]=dp[i];
        }
        return dp[str.size()];
    }
};

礼物的最大价值

在一个 m*n 的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

题目链接

从左上角出发 -> 右下角可以拿到的最大价值的礼物

设dp[i][j] 表示在i行j列时能拿到的礼物 、又当前格子只能由左边和上边过来 -> dp[i][j]+=fmax(dp[i-1][j],dp[i][j-1])

位于第一行或者第一列的时候，只能由左边来，或者只能由上边来

class Solution {
public:
    int maxValue(vector<vector<int>>& grid) {
        int row=grid.size();
        int col=grid[0].size();
        for(int i=0;i<row;i++)
        {
            for(int j=0;j<col;j++)
            {
              if(i==0||j==0)
              {
                  if(i!=0)//第一列
                    grid[i][j]+=grid[i-1][j];
                  if(j!=0)//第一行
                    grid[i][j]+=grid[i][j-1];
              }
              else
                grid[i][j]+=fmax(grid[i-1][j],grid[i][j-1]);
            }
        }
        return grid[row-1][col-1];
    }
};

最长不含重复字符的字符串

请从字符串中找出一个最长的不包含重复字符的子字符串，计算该最长子字符串的长度。

题目链接

解法：

给定一个滑动窗口和标记数组 -> 如果字符没有出现过则添加到滑动窗口之中、如果出现了，则将滑动窗口内的值依次出队列

class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        deque<char>de;//滑动窗口
        vector<int> arr(200,0);//统计数组
        int max=0;//记录最长的长度

        for(int i=0;i<s.size();i++)
        {
            if(arr[s[i]]==0)//表示没有出现过，直接进入滑动窗口
            {
                arr[s[i]]++;
                de.push_back(s[i]);
            }
            else//表示不是第一次出现
            {
                max=fmax(max,de.size());//先将最长的长度保存下来
                while(arr[s[i]]!=0)//不为0说明还没有将该字符删掉
                {
                    arr[de.front()]--;//计数器减1
                    de.pop_front();//删掉
                }
                //此时说明删掉了，再窗口
                    de.push_back(s[i]);
                    arr[s[i]]++;
            }
        }
        max=fmax(max,de.size());
        return max;

    }
};

丑数

我们把只包含质因子 2、3 和 5 的数称作丑数（Ugly Number）。求按从小到大的顺序的第 n 个丑数。

题目链接

设dp[i]表示第i个丑数，初始化dp[0]=1

由丑数的定义可知 当前丑数肯定是前面的某一个丑数 *(2/3/5)其中的一个得到

-> 此时给定三个变量，都从下标为0开始

-> 三个变量的下标分别固定dp[one] * 2 dp[there] * 3 dp[five] * 5 每次都取其中的最小值填入dp数组之中，这一步完成了排序的功能

->去重、选完数字之后进行判断、如果dp[sub] * n ==dp[i] 说明这个数已经拿到了 ，则sub++

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int>dp(n,0);
        dp[0]=1;
        int one=0;
        int there=0;
        int five=0;
        for(int i=1;i<n;i++)
        {
            dp[i]=fmin(fmin(dp[one]*2,dp[there]*3),dp[five]*5);//三个数中取最小的

        //更新坐标+去重
            if(dp[i]==dp[one]*2)
                one++;
            if(dp[i]==dp[there]*3)
                there++;
            if(dp[i]==dp[five]*5)
                five++;
        }
        return dp[n-1];
    }
};

第一个只出现一次的字符

在字符串 s 中找出第一个只出现一次的字符。如果没有，返回一个单空格。 s 只包含小写字母。

题目链接

class Solution {
public:
    char firstUniqChar(string s) {
        int arr[26]={0};
        for(auto&e:s)
        {
            arr[e-'a']++;
        }
        for(auto&e:s)
        {
            if(arr[e-'a']==1)
                return e;
        }
        return ' ';
    }
};

数组中的逆序对

题目链接

在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
在这里插入图片描述

递归法：

class Solution {
public:
    void Merge(vector<int>&nums,vector<int>&temp,int &count,int begin,int mid,int end)
    {
        int begin1=begin;
        int end1=mid;
        int begin2=mid+1;
        int end2=end;

        int start=begin;
        while(begin1<=end1&&begin2<=end2)
        {
            if(nums[begin1]<=nums[begin2])
            {
                temp[start++]=nums[begin1];
                begin1++;
                count+=begin2-mid-1;//后面的下去了几个
            }
            else
            {
                temp[start++]=nums[begin2];
                begin2++;
            }
        }
        while(begin1<=end1)//前面的还有剩余
        {
            temp[start++]=nums[begin1++];
            count+=begin2-mid-1;
        }
        while(begin2<=end2)//后面的还有剩余
            temp[start++]=nums[begin2++];

        //塞回原数组
        for(int i=begin;i<=end;i++)
        {
            nums[i]=temp[i];
        }
    }

    void Merger(vector<int>&nums,vector<int>&temp,int &count,int begin,int end)
    {
        if(begin>=end)
            return;
        int mid=begin+(end-begin)/2;
        Merger(nums,temp,count,begin,mid);
        Merger(nums,temp,count,mid+1,end);

        Merge(nums,temp,count,begin,mid,end);
    }
    int reversePairs(vector<int>& nums) {
     vector<int> temp(nums.size(),0);
     int count=0;
     Merger(nums,temp,count,0,nums.size()-1);
     return count;
    }
};

非递归法：

class Solution {
public:
      void Merge(vector<int>&nums,vector<int>&temp,int &count,int begin,int mid,int end)
    {
        int begin1=begin;
        int end1=mid;
        int begin2=mid+1;
        int end2=end;

        int start=begin;
        while(begin1<=end1&&begin2<=end2)
        {
            if(nums[begin1]<=nums[begin2])
            {
                temp[start++]=nums[begin1];
                begin1++;
                count+=begin2-mid-1;//后面的下去了几个
            }
            else
            {
                temp[start++]=nums[begin2];
                begin2++;
            }
        }
        while(begin1<=end1)//前面的还有剩余
        {
            temp[start++]=nums[begin1++];
            count+=begin2-mid-1;
        }
        while(begin2<=end2)//后面的还有剩余
            temp[start++]=nums[begin2++];

        //塞回原数组
        for(int i=begin;i<=end;i++)
        {
            nums[i]=temp[i];
        }
    }

    int reversePairs(vector<int>& nums) {
        int count=0;
        vector<int>temp(nums.size(),0);
        int gap=1;
        int size=nums.size();
        while(gap<nums.size())
        {
            for(int i=0;i<size;i+=2*gap)
            {
                int begin=i;
                int mid=begin+gap-1;//end1  mid+1=begin2
                int end=mid+gap;//end2
                
                if(mid>=size)//后面的数组没了
                    break;
                if(end>=size)//后面的数组不全
                    end=size-1;

                Merge(nums,temp,count,begin,mid,end);
            }
            gap*=2;
        }
        return count;
    }
};

两个链表的第一个公共节点

输入两个链表，找出它们的第一个公共节点。

题目链接

image-20210522213500185

class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        ListNode *a=headA;
        ListNode *b=headB;

        while(a!=NULL||b!=NULL)
        {
            if(a==b)
                return a;
            
            if(a==NULL)
                a=headB;
            else
                a=a->next;
            
            if(b==NULL)
                b=headA;
            else    
                b=b->next;
        }
        return NULL;
    }
};

在排序数组中查找数字|

统计一个数字在排序数组中出现的次数。

题目链接

image-20210522215345343

class Solution {
public:
    void Find(vector<int>&nums,int target,int &key)
    {
        int left=0;
        int right=nums.size()-1;

        while(left<=right)
        {
            int mid=left+(right-left)/2;
            if(target>nums[mid])
                left++;
            else if(target<nums[mid])
                right--;
            else
                left=mid+1;
        }
        key=right;
    }
    int search(vector<int>& nums, int target) {
        int begin=0;
        int end=nums.size()-1;

        int left=0;
        int right=0;

        Find(nums,target,right);
        Find(nums,target-1,left);//利用target-1，如果存在则找到右边界，如果不存在最后函数越界的边界就是最后一个target

        return right-left;
    }
};

n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

题目链接

image-20210522221641956

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int left=0;
        int right=nums.size();

        while(left<right)
        {
            int mid=left+(right-left)/2;
            if(nums[mid]==mid)//前面没有乱
                left=mid+1;
            else//前面乱了
                right=mid;
        }
        return right;
    }
};

二叉搜索树的第K大节点

给定一棵二叉搜索树，请找出其中第k大的节点。

题目链接

二叉搜索树的 右根左为降序 -> 用这个方式来遍历这颗树

class Solution {
public:

    void _kthLargest(TreeNode* root,int &k,int &ret)
    {
        if(root==NULL||k==0)
            return ;
        
        _kthLargest(root->right,k,ret);
       
        k--;
        if(k==0)
        {
            ret=root->val;
            return ;
        }
        _kthLargest(root->left,k,ret);

    }
    
    int kthLargest(TreeNode* root, int k) {
        //右根左
        int ret=0;
        _kthLargest(root,k,ret);
        return ret;
    }
};

二叉树的深度

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

题目链接

一颗树的高度=它的左子树的高度+1和右子树高度+1之中的较大值

class Solution {
public:
    int count=0;

    int maxDepth(TreeNode* root) {
        if(root==NULL)
            return 0;
            
        int left=maxDepth(root->left)+1;
        int right=maxDepth(root->right)+1;

        return fmax(left,right);
    }
};

平衡二叉树

输入一棵二叉树的根节点，判断该树是不是平衡二叉树。如果某二叉树中任意节点的左右子树的深度相差不超过1，那么它就是一棵平衡二叉树。

题目链接

方法1：

求出每一个节点的左右子树高度然后进行比较

求每个节点的左右子树高度的时间复杂度=N，总共需要求N个节点 -> 时间复杂度为 O(N^2)

class Solution {
public:
    int _isBalanced(TreeNode* root)
    {
        if(root==NULL)
            return 0;
        int left=_isBalanced(root->left)+1;
        int right=_isBalanced(root->right)+1;

        return fmax(left,right);
    }
    bool isBalanced(TreeNode* root) {
        if(root==NULL)
            return true;
        
        int left=_isBalanced(root->left);//左子树高度
        int right=_isBalanced(root->right);//右子树高度

        return 
        abs(left-right)<2&&
        isBalanced(root->left)&&
        isBalanced(root->right);
    }
};

方法2：

方法1由于要遍历整棵树的所有节点，因此时间复杂度很高。如果采用后序遍历的办法，自底向上判断，并且将当前的高度记录下来，返回给上一层，则只需要O(N)的时间复杂度

class Solution {
public:
    bool _isBalanced(TreeNode* root,int &depth)
    {
        if(root==NULL)
            return true;
        //给定变量记录左右子树的高度
        int left_depth=0;
        int right_depth=0;
		
		//先左再右 ->后序遍历
        bool left=_isBalanced(root->left,left_depth);
        bool right=_isBalanced(root->right,right_depth);
		
		//左右子树的深度不满足
        if(abs(left_depth-right_depth)>1)
            return false;
            
		//将深度记录下来 ->由于是引用因此可以返回给上一层
        depth=fmax(left_depth,right_depth)+1;

        return left&&right; 

    }
    bool isBalanced(TreeNode* root) {
        int depth=0;
        return _isBalanced(root,depth);

    }
};

方法3：

方法2中虽然进行了时间复杂度上面的优化，但是每次递归都引入了四个变量，主要是因为需要变量保存高度和保存bool结果，下面将再次进行优化，利用数字-1来表示不是平衡二叉树

class Solution {
public:
    int _isBalanced(TreeNode* root)
    {
        if(root==NULL)
            return 0;
        
        int left=_isBalanced(root->left);//获得左子树的高度
        int right=_isBalanced(root->right);//获得右子树的高度

        if(left==-1||right==-1||abs(left-right)>1)
            return -1;
        
        return fmax(left,right)+1;//返回高度
    }
    bool isBalanced(TreeNode* root) {
        return _isBalanced(root)!=-1;
    }
};

数组中出现的次数|

一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。

题目链接

1.将所有的数组进行异或 ->得到一个数num

2.在num之中找一个比特位不为0的位置将所有的数据分成两组(出现两次的数进行异或都变成了0，num就是两个自出现一次的异或结果)

3.两组数组分别异或，最后得到的就是所求的两个数组

class Solution {
public:
    vector<int> singleNumbers(vector<int>& nums) {
        int num=0;
        for(auto&e:nums)
        {
            num^=e;
        }

        int flag=0;//标记位置
        for(int i=0;i<32;i++)
        {
            if((num>>i)&1!=0)//找到为1的位
            {
                flag=i;
                break;
            }
        }

        int ret1=0;
        int ret2=0;
    //分成两组
        for(auto&e:nums)
        {
            if((e>>flag)&1)
                ret1^=e;
            else
                ret2^=e;
        }
    vector<int> ret(2,0);
    ret[0]=ret1;
    ret[1]=ret2;
    return ret;
    }
};

数组中出现数字的次数||

在一个数组 nums 中除一个数字只出现一次之外，其他数字都出现了三次。请找出那个只出现一次的数字。

题目链接

方法1：

利用map进行统计计算

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        map<int,int> count_map;

        for(auto&e:nums)//统计次数 -> O(NlogN)
        {
            count_map[e]++;
        }
        
        for(auto&e:count_map) -> 遍历一遍 O(N)
        {
            if(e.second==1)
                return e.first;
        }

        return 0;
    }
};

方法2：

将所有数字的比特位全部加起来，然后每个比特位都对3取余组合起来，得到的就是只出现1次的数字

class Solution {
public:
    int singleNumber(vector<int>& nums) {
        vector<int>count(32,0);

        for(int i=0;i<32;i++)//统计每个比特位的次数 ->O(N)
        {
            for(auto &num:nums)
            {
               if((num&(1<<i))!=0)
                count[i]++;
            }
        }

        int ret=0;
        for(int i=0;i<32;i++)//将每个比特位组合起来
        {
            ret^=((count[i]%3)<<i);
        }

        return ret;
    }
};

和为S的数字

输入一个递增排序的数组和一个数字s，在数组中查找两个数，使得它们的和正好是s。如果有多对数字的和等于s，则输出任意一对即可。

题目链接

一前一后双指针

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        int left=0;
        int right=nums.size()-1;
        vector<int>ret(2,0);
        while(left<right)
        {
            int sum=nums[left]+nums[right];
            if(sum==target)
            {
                ret[0]=nums[left];
                ret[1]=nums[right];
                break;
            }
            if(sum<target)
                left++;
            else
                right--;

        }
        return ret;
    }
};

翻转单词的顺序

输入一个英文句子，翻转句子中单词的顺序，但单词内字符的顺序不变。为简单起见，标点符号和普通字母一样处理。例如输入字符串"I am a student. “，则输出"student. a am I”。

题目链接

1.给定下标，位于字符串最后的位置

2.每次循环先去除空格

3.将当前短字符串加入临时字符串之中

4.颠倒临时字符串假如返回字符串之中

class Solution {
public:
    string reverseWords(string s) {
        if(s=="")
            return s;

        int pos=s.size()-1;
        string ret;
        while(pos>=0)
        {
            string temp;
            while(pos>=0&&s[pos]==' ')//去空格
                pos--;
            while(pos>=0&&s[pos]!=' ')//从后往前获取字符串
            {
                temp+=s[pos];
                pos--;
            }
            
            if(!temp.empty())//添加至返回数组之中
            {
                reverse(temp.begin(),temp.end());//颠倒
                ret+=temp;
                ret+=" ";//加上空格
            }
            
        }

        if(ret.size()!=0)
        ret.erase(ret.end()-1);//删掉最后一个空格
        return ret;

    }
};

左旋字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

题目链接

构造两个字符串相加

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        string ret(s.begin()+n,s.end());
        string temp(s.begin(),s.begin()+n);
        ret+=temp;
        return ret;
    }
};

滑动窗口的最大值

给定一个数组 nums 和滑动窗口的大小 k，请找出所有滑动窗口里的最大值。

题目链接

1.给定一个滑动窗口，保存数组最大值的下标，并且保证窗口内的所有值都属于同一个窗口，因此我们保证窗口前端的值是最大的即可以每次用O(1)的时间获取这个最大的数字

2.我们不能将值保存在滑动窗口之中，而应该将值对应的下标保存起来，因为值是会**“失效”**的。用i表示当前元素下标，用sub表示窗口首部的下标，当i-sub>=k时，sub就不再当前窗口之中了，因此应该将其出队 -> 这一步保证了窗口内的所有值都处于同一窗口

3.当有新元素来的时候，如果新来的元素大于窗尾的值，则利用循环，将所有小于这个数的值pop出去，因为所有的数字都处于同一窗口，小于当前值的数字已经失效了 -> 这一步保证了，窗口的值是最大的

4.当滑动窗口"装满时"，才能从中获取最大元素进行返回。 当 i+1>=k时表示正好装满，在此之后，每添加一个元素，窗口都会往后挪动一位，即每次都要从窗口之中取出一个最大的值

image-20210524210607450

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ret;
        deque<int> qe;
        if(nums.empty())
            return ret;

        for(int i=0;i<nums.size();i++)
        {
            //新来的元素>队列之中的元素，说明最大值发生了变化
            while(!qe.empty()&&nums[i]>=nums[qe.back()])
                qe.pop_back();
            
            //窗口之中保存的是下标
            //i-qe.front()>=k，说明这个元素不在窗口之中了
            while(!qe.empty()&&i-qe.front()>=k)
                qe.pop_front();
            
            qe.push_back(i);//将下标存入数组中，因为要比较元素是否"过期"

            if(i+1>=k)//经过的元素可以满足一个窗口了
                ret.push_back(nums[qe.front()]);
        }
        return ret;
    }
};

队列的最大值

请定义一个队列并实现函数 max_value 得到队列里的最大值，要求函数max_value、push_back 和 pop_front 的均摊时间复杂度都是O(1)。若队列为空，pop_front 和 max_value 需要返回 -1

题目链接

1.给定一个普通队列qe和双端队列max_qe

2.当新来的元素比max_qe的队尾元素大的时候，则将队尾元素出队 ->因为新来的元素在后面，出队的时间就越晚，最大值永远不是他们

3.出队的时候，需要判断max_qe中是否是相同的值，如果是的话，则需要进行出队处理 -> 所以第二步之中判断不能带等号，因为带等号则只有一个数，出完之后就没有了

class MaxQueue {
public:
    MaxQueue() {

    }
    
    int max_value() {
        if(qe.empty())
            return -1;

        return max_qe.front();
    }
    
    void push_back(int value) {
        qe.push(value);//入到普通队列

        while(!max_qe.empty()&&value>max_qe.back())//新来的元素大于前面的元素
            max_qe.pop_back();
        
        max_qe.push_back(value);
    }
    
    int pop_front() {
        if(qe.empty())
            return -1;
        //判断最大队列是否需要pop
        int value=qe.front();
        if(max_qe.front()==value)
            max_qe.pop_front();

        qe.pop();
        return value;
    }
    deque<int> max_qe;
    queue<int> qe;
};

n个骰子的点数

把n个骰子扔在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能的值出现的概率。你需要用一个浮点数数组返回答案，其中第 i 个元素代表这 n 个骰子所能掷出的点数集合中第 i 小的那个的概率。

题目链接

image-20210526105127194

class Solution {
public:
    vector<double> dicesProbability(int n) {
        //每增加一颗骰子，整体数值增大5
        //设dp[i][j]表示i颗骰子时，数值为j的几率 -> dp[i][j]=dp[i-1][j] + dp[i-1][j-1]*(1/6);+dp[i-1][j-2]*(1/6)

        vector<double>ret(7,1.0/6);//初始化
        ret[0]=0;//数为0时候的几率
        
        for(int i=2;i<=n;i++)//骰子个数
        {
            int size=ret.size()+5+1;//每多一颗骰子，空间增大5个
            vector<double> temp(size,0);
            for(int j=i;j<size;j++)//几颗骰子最小值就从几开始(骰子的最小数为1),最大值每多一颗就加5
            {
                for(int k=1;k<=6;k++)//k表示骰子点数
                {
                    if(j-k>=0&&j-k<ret.size())
                     temp[j]+=ret[j-k]/6;
                }
            }
            ret.swap(temp);
        }
       vector<double> ret2(ret.begin()+n,ret.end());
       return ret2;
    }
};

扑克牌中的顺子

从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2～10为数字本身，A为1，J为11，Q为12，K为13，而大、小王为 0 ，可以看成任意数字。A 不能视为 14。

题目链接

1.抽出5张牌，除了大小王(0)，其余的牌都不能出现重复的(大小王可以变作任意的牌）

2.到了第二步说明牌中没有了重复的元素，此时我们需要找到除了大小王(0)之外的最小值min和最大值max。

如果max-min>=5，即使剩下的三张牌都是0(可随意变化)也填不满剩下的空缺

=> 求解条件：数组中不能有重复的元素出现&&最大值-最小值(不能是0)<5

class Solution {
public:
    bool isStraight(vector<int>& nums) {
        //5张牌不能有重复的(0除外，0可以表示任何数)
        //最大-最小<5
        //满足上面两个条件即可满足，顺子的条件

        vector<int> count_arr(14,0); //牌从 0 - 13   

        int min=20;
        int max=nums[1];
        for(auto&e:nums)//统计次数
        {
            if(e==0)//跳过王
                continue;
            
            min=fmin(min,e);
            max=fmax(max,e);

            if(count_arr[e]!=0)//出现重复的
                return false;
            else
                count_arr[e]++;
        }
        if(max-min<5)
            return true;

            return false;
    }
};

圆圈中最后剩下的数字

0,1,···,n-1这n个数字排成一个圆圈，从数字0开始，每次从这个圆圈里删除第m个数字（删除后从下一个数字开始计数）。求出这个圆圈里剩下的最后一个数字。例如，0、1、2、3、4这5个数字组成一个圆圈，从数字0开始每次删除第3个数字，则删除的前4个数字依次是2、0、4、1，因此最后剩下的数字是3。

题目链接

image-20210526142215737

class Solution {
public:
    int lastRemaining(int n, int m) {
        int sub=0;

        for(int i=2;i<=n;i++)
        {
            sub=(sub+m)%i;
        }
        return sub;
    }
};

股票的最大利润

假设把某股票的价格按照时间先后顺序存储在数组中，请问买卖该股票一次可能获得的最大利润是多少

题目链接

给定两个变量：
min记录最低股价
max记录最大利润

根据时间线从前往后：
如果当天的股票价格低于手上的股票价格，我们就更换股票
如果当天的股票价格高于手上的股票价格，我们可以"尝试"卖出，尝试卖出的价格高于手头的利润，则更新利润max

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size()==0)
            return 0;

        int min=prices[0];
        int max=0;
        
        for(auto&e:prices)
        {
            if(e>min)//当日的股价大于手上的股票
                max=fmax(e-min,max);
            else//e<min
                min=e;//更新手上的股票
        }
        return max;
    }
};

求 1+2+…+n

求 1+2+...+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

题目链接

方法1：

利用C++类构静态成员的特性：

1.给定两个静态成员变量，num表示当前位置的值，ret表示当前位置的总和

2.每次调用构造函数num++， ret+=num

3.创建n个对象既可调用n次构造函数

class Add
{
public:
    Add()
    {
        num++;
        ret+=num;
    }

    static int num;
    static int ret;
};
int Add::num=0;
int Add::ret=0;
class Solution
{
public:
    int sumNums(int n) {
        Add::num=0;//防止多组测试用例
        Add::ret=0;

        new Add[n];//创建n个对象
        return Add::ret; 
    }
};

方法2：

通常的递归写法为

class Solution {
public:
    int sumNums(int n) {
    if(n<0)
    	return 0;
    return n+sumNums(n-1)
    }
};

由于题目的限制，不能使用if判断语句，此时我们可以利用&&的短路原理构造一个类似if的语句

class Solution {
public:

    int sumNums(int n) {
    int ret=n;
    n>0&&(ret+=sumNums(n-1));
    return ret;
    }
};

构建乘积数组

给定一个数组 A[0,1,…,n-1]，请构建一个数组 B[0,1,…,n-1]，其中 B[i] 的值是数组 A 中除了下标 i 以外的元素的积, 即 B[i]=A[0]×A[1]×…×A[i-1]×A[i+1]×…×A[n-1]。不能使用除法。

题目链接

由题可知B[i]的值为，A之中除了下标i对应的值之外，其余所有值的乘积

如果每个数都去遍历一变数组，所需要的时间复杂度是O(N^2),当数据量足够大的时候，会导致超时

这里需要给定两个变量，保存前面已经算出来的值，这样，就可以通过O(N)的方式得到最终的结果

给定两个变量，left和right 分别从左往右、从右往左进行迭代 -> 在迭代之前就如返回数组中的值进行相乘(初始化为1)，由于是迭代之前与其相乘，left保证了i下标前面的元素全部乘进来了，right保证了r后面的元素全部乘进来了，并且合理的利用了前面已经求出来的值，即只需要O(N)的时间复杂度

image-20210526153116445

class Solution {
public:
    vector<int> constructArr(vector<int>& a) {
        vector<int> ret(a.size(),1);
        int left=1;
        int right=1;

        for(int i=0;i<a.size();i++)//从左往右添加
        {
            ret[i]*=left;
            left*=a[i];
        }

        for(int i=a.size()-1;i>=0;i--)//从右往左添加
        {
            ret[i]*=right;
            right*=a[i];
        }
        return ret;
    }
};

把字符串转化成整数

写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。

题目链接

1.首先去除前导空格

2.判断符号，并且将其保存

3.最重要的一步，也是比较复杂的一步，越界的判断

image-20210526175744788

class Solution {
public:
    int strToInt(string str) {
        int ret=0;
        int len=str.size();
        int sub=0;
        int flag=1;

            while(sub<len&&str[sub]==' ')//去除前导空格
            {
                sub++;
            }
            //此时前导空格已经去了

            //判断符号
            if(sub<len&&str[sub]=='-')
            {
                flag=-1;
                sub++;
            }
            if(sub<len&&str[sub]=='+')
            {
                if(flag==-1)//已经出现过符号了
                    return ret;
                sub++;
            }

            //此时进行数字的转换

            int max=INT_MAX;
            if(flag==-1)
                max=INT_MIN;
            
            int rear=INT_MAX;//取得最大值的尾巴,取整数尾巴即可
            max=abs(max/10);

            while(sub<len)
            {
                if(str[sub]<'0'||str[sub]>'9')//此时不是数字
                    break;
                int num=str[sub]-'0';

                if(ret>=max)//越界了
                {
                    if(ret==max&&num<=rear)//此时是最大整数的尾巴，小于则加上，大于不管正负都已经是返回最大值了
                    {
                        ret=ret*10+num;
                        break;
                    }
                    if(flag==1)
                        return INT_MAX;

                    return INT_MIN;
                }

                ret=ret*10+num;
                sub++;
            }
                return ret*flag;
    }
};

二叉搜索树的最近公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

题目链接

image-20210526163955615

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        while(root)
        {
            if(root->val>p->val&&root->val>q->val)
                root=root->left;
            else if(root->val<p->val&&root->val<q->val)
                root=root->right;
            else    
                return root;
        }
        return nullptr;
    }
};

二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

题目链接

image-20210526165159175

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(root==nullptr)
            return root;
        
        if(root==p||root==q)//找到了
            return root;

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

        if(left==nullptr)//都在右侧
            return right;
        if(right==nullptr)//都在左侧
            return left;
        return root;//分布在两侧
    }
};

数字序列中某一位数字

数字以0123456789101112131415…的格式序列化到一个字符序列中。在这个序列中，第5位（从下标0开始计数）是5，第13位是1，第19位是4，等等。请写一个函数，求任意第n位对应的数字。

题目链接

image-20210526191912946

class Solution {
public:
    int findNthDigit(int n) {
        if(n<10)
            return n;

        long long  sum=9;//表示位置有多少个"数"
        long long  count=1;//表示当前n在哪个区间
        long long  prev=sum;
        while(n>sum)//求出n所在的区间范围
        {
            count++;
            prev=sum;//保留上一个区间的终止位置时有多少位数
            sum+=count*9*pow(10,count-1);
        }

        //此时n要取的数在count位数的区间内
        long long  num=pow(10,count-1);//当前区间的起始位置数的大小
        prev+=count;//上边往后挪动了一个数


        while(prev<n)
        {
            int size1=(n-prev)/count;
            int size2=(n-prev)%count;
            num+=size1;
            prev+=size1*count;
            if(size2!=0)
            {
                num++;
                prev+=count;
            }
        }

        int lable=prev-n;//取这个数的第几位
        string str=to_string(num);
        reverse(str.begin(),str.end());
        return str[lable]-'0';
    }
};

序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树。

题目链接

序列化过程：序列化过程就是利用一个队列，对二叉树进行层序遍历

反序列化过程：

image-20210526212745816

class Codec {
public:

    // Encodes a tree to a single string.
    string serialize(TreeNode* root) {//层序遍历

        string str;
        str+='[';
        queue<TreeNode*> qe;
        
        if(root)//非空入队
            qe.push(root);
        else
        {
            str+="]";
            return str;   //空串返回"[]"
        }

        while(!qe.empty())
        {
            TreeNode* node=qe.front();
            qe.pop();

            if(node==nullptr)
                str+="null,";
            else
            {
                str+=to_string(node->val);
                str+=',';
                qe.push(node->left);       
                qe.push(node->right);       
            }
        }
        str.erase(str.end()-1);//删除最后一个“,”
        str+=']';
        return str;
    }

    // Decodes your encoded data to tree.
    TreeNode* deserialize(string data) {
        if(data.size()==2)//空树，只有"[]"
            return nullptr;
        
        queue<string> arr;
        int sub=1;//跳过第一个,
        
//将字符转移到队列之中
        while(sub<data.size()-1)//跳过最后一个]
        {
            if(data[sub]=='n')
            {
                arr.push("null");
                sub+=5;
            }
            else
            {
                string temp;
                while(sub<data.size()-1&&data[sub]!=',')
                {
                    temp+=data[sub];
                    sub++;
                }
                sub++;//跳过,
                arr.push(temp);
            }
        }

        queue<TreeNode*> qe;//保存节点的队列
        TreeNode *root=new TreeNode(stoi(arr.front()));
        arr.pop();
        qe.push(root);

        while(!qe.empty()&&!arr.empty())
        {
            TreeNode* node=qe.front();
            qe.pop();

        //填写左树
            if(arr.front()!="null")
                node->left= new TreeNode(stoi(arr.front()));
            if(node->left!=nullptr)//不为空入队
                qe.push(node->left);
            arr.pop();

        //填写右树
            if(arr.front()!="null")
                node->right=new TreeNode(stoi(arr.front()));
            if(node->right!=nullptr)
                qe.push(node->right);
            arr.pop();
        }
        return root;
    }
};

1~n 整数中 1出现的次数

输入一个整数 n ，求1～n这n个整数的十进制表示中1出现的次数。例如，输入12，1～12这些整数中包含1 的数字有1、10、11和12，1一共出现了5次。

题目链接

image-20210527082235124

class Solution {
public:
    int countDigitOne(int n) {
        long long count=0;
        long long base=n/10;//位于十位
        long long cur=n%10;//位于个位
        long long index=1;//指数
        long long prev=0;//记录cur后面的数

        while(cur!=0||base!=0)
        {
            if(cur<1)
                count+=base*index;
            else if(cur>1)
                count+=base*index + index;
            else    
                count+=base*index +prev + 1;

            //进行迭代
            prev=cur*index + prev;
            cur=base%10;
            base/=10;
            index*=10;
        }

        return (int)count;
    }
};

正则表达式匹配

请实现一个函数用来匹配包含’. ‘和’‘的正则表达式。模式中的字符’.‘表示任意一个字符，而’'表示它前面的字符可以出现任意次（含0次）。在本题中，匹配是指字符串的所有字符匹配整个模式。例如，字符串"aaa"与模式"a.a"和"abaca"匹配，但与"aa.a"和"ab*a"均不匹配。

题目链接

image-20210527103842129

class Solution {
public:
    bool isMatch(string s, string p) {
        int lens=s.size();
        int lenp=p.size();

        //dp[i][j] 表示s的前i个字符和p的前j个字符是否是匹配的
        vector<vector<bool>> dp(lens+1,vector<bool>(lenp+1,false));
        dp[0][0]=true;//两个空串时是匹配的

        for(int i=1;i<lenp;i+=2)//始终保持是空串
        {
               if(p[i]!='*')
                break;
            dp[0][i+1]=true;
        }

        for(int i=0;i<lens;i++)
        {
            for(int j=0;j<lenp;j++)
            {
                if(p[j]=='*')
                {
                    if(dp[i+1][j-1]==true)//*前面的字符出现0次
                        dp[i+1][j+1]=true;
                    else if(dp[i][j+1]&&(p[j-1]=='.'||s[i]==p[j-1]))//*前面的次数出现1次
                        dp[i+1][j+1]=true;
                }
                else//p[j]=="."或者普通字符
                {
                    if(dp[i][j]==true)//前面的是匹配的
                    {
                        if(p[j]=='.')// .匹配任意
                            dp[i+1][j+1]=true;
                        else if(s[i]==p[j])//当前字符是匹配的
                            dp[i+1][j+1]=true;
                    }
                }
            }
        }
        return dp[lens][lenp];
    }
};
ych9527
关注
专栏目录
剑指offer题解(C++).docx
07-17
此资源是剑指OFFER的题解(C++)，由本人在刷剑指OFFER题的期间整理，其中有整理牛客网讨论区的代码+剑指OFFER书中的代码+自己编写的代码，方法很全，且附有解析和思路，很方便大家在刷题时参考。 资源中题目顺序参照牛客网上的顺序。 作者：Sidney.Tan
剑指offer题目题解java版+c++版+Python版.zip
07-15
总之，《剑指Offer》题解涵盖了编程基础、算法、设计模式等多个方面，通过不同语言的实现，帮助开发者巩固编程基础，提升解决实际问题的能力。无论是准备面试还是提升自身技术，都是不可或缺的学习资源。
剑指offer（一）C++版
葵的博客
04-21 626
1.二维数组中的查找 2.替换空格 3.从尾到头打印链表 4.重建二叉树 5.用两个栈实现队列
《剑指offer》题目 C++详细题解
qq_64446981的博客
08-05 682
这个过程，会让[left，right]区间缩小，这个过程中，left永远在原数组前半部分，right永远在原数组的后半部分，而范围会一直缩小，当left和right相邻时，left指向的位置，就是最小元素的位置，但是，因为题目说的是非递减，也就意味着数据允许重复，因为有重复值，就可能会有a[left] == a[mid] ==a[right]的情况，此时我们就不能用单纯的二分算法模板来写这个题目，我们此时需要单独处理一下有重复值的情况，我们上面是采用的右端点进行判断，同时我们也可以使用左端点进行判断。
剑指offer c语言 pdf,《剑指Offer》-Exercise(C语言)
weixin_30575517的博客
05-21 643
面试题4:二维数组中的查找/*测试数据：查找7:41 2 8 92 4 9 124 7 10 136 8 11 151-----查找14：41 2 8 92 4 9 124 7 10 136 8 11 150*/#include //注意：二维数组用做函数形参int searchIna(int a[][4],int s,int n) {int i = 0,j = n-1;while (a[i][j...
剑指offer c++
酸乳乳酸的博客
12-22 304
3.从你头到尾打印链表 /** * struct ListNode { * int val; * struct ListNode *next; * ListNode(int x) : * val(x), next(NULL) { * } * }; */ class Solution { public: ...
剑指offer (c++版)
boshuzhang的专栏
07-15 1621
https://blog.csdn.net/u012477435/article/details/83351659#_1992
基于C++的剑指Offer面试题解设计源码
最新发布
09-23
该项目是基于C++的剑指Offer面试题解设计源码，共计338个文件，其中包括207个C++源文件、66个Markdown文档、18个VCXProj项目文件、18个Filter配置文件、10个JPG图片文件、2个Python脚本、2个PNG图片文件、2个C源文件...
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
蓝桥杯竞赛练习题的题解(C/C++/Java)
03-27
【蓝桥杯竞赛练习题的题解(C/C++/Java)】 蓝桥杯全国软件与信息技术专业人才大赛是一项旨在推动软件和信息技术行业发展、培养创新型工程科技人才的重要赛事。该比赛涵盖了C、C++和Java等多种编程语言，为参赛者提供...
剑指offer题解(C++版)
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
09-23 2394
剑指offer习题题解，C++版本代码，并附带个人算法题解题方法总结。题目包括数据结构：数组、链表、栈和队列等，以及常见的算法：排序、分治、回溯、递归、贪心、动态规划等。
剑指offer（C++）1
08-04
剑指offer（C++）1
剑指offer第二版-源代码（C++）
04-09
根据书上思路和自己的理解，整理出的尽可能精简的代码。全部66题已通过测试，并附有详细注释。
leetcode剑指-Sword_finger_offer:剑指offer思路及代码(leetcode版，C++)
07-07
leetcode剑指 Sword_finger_offer 剑指offer思路及代码(leetcode版，C++)
剑指offer（C++版本）
热门推荐
u012477435的博客
10-24 2万+
剑指offer（c++版本）二维数组查找替换空格从尾到头打印链表重建二叉树 二维数组查找 在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。 class Solution { public: bool Find(int target, vector&amp;amp;amp;amp;amp;amp;amp;amp;...
剑指offer（第二版）C++笔记（一）
weixin_46819249的博客
03-24 2065
栈与队列，链表，字符串，查找算法
剑指offer第二版(C++实现)
温故知新
06-14 3089
剑指offer题目
剑指offer-第2版-c++
fgs的博客
07-11 665
这里提供C++版剑指offer书籍及相关代码实现： 百度云链接:链接：https://pan.baidu.com/s/1dp0kf394HQDZQyQEKrlV7A 提取码：c3yj 若链接失效，可关注下方微信公众号，回复关键字：剑指offer 若有任何疑问，可在微信公众号留言，祝君好运！ ...
剑指Offer C++题解：二维查找与替换空格算法详解
剑指OFFER题解(C++)文档是一份全面的编程题解资料，针对C++语言，特别适合那些正在刷《剑指Offer》这本书中的题目或者希望提升算法能力的学习者。这份资源由作者Sidney.Tan整理，包含了牛客网讨论区、原著书中的代码...
评论 26
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值