剑指Offer（31天）_剑指 offer 天数限制-CSDN博客

本文链接：https://blog.csdn.net/qq_43309907/article/details/122496570

剑指offer

day01

用两个栈实现队列

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

示例 1：

输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：

输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：

1 <= values <= 10000
最多会对 appendTail、deleteHead 进行 10000 次调用

代码：

#include<iostream>
#include<stack>
using namespace std;
class CQueue {
private:
    stack<int> stack_group[2];
public:
    CQueue() {

    }
    
    void appendTail(int value) {
        stack_group[0].push(value);
    }
    
    int deleteHead() {
        int delete_one;
        if(stack_group[1].empty()){
            if(stack_group[0].empty()){
                return -1;
            }else{
                while(!stack_group[0].empty()){
                    int temp = stack_group[0].top();
                    stack_group[0].pop();
                    stack_group[1].push(temp);
                }
                delete_one = stack_group[1].top();
                stack_group[1].pop();
            }
        }else{
            delete_one = stack_group[1].top();
            stack_group[1].pop();
        }
        return delete_one;
    }
};

int main(){
    CQueue c ;
    c.appendTail(1);
    c.appendTail(2);
    c.appendTail(3);
    c.appendTail(4);
    c.appendTail(5);
    c.deleteHead();
    c.deleteHead();
    c.deleteHead();
    c.deleteHead();
    c.deleteHead();
    c.deleteHead();
    return 0;
}

包含min函数的栈

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

示例:

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.
 

提示：

各函数的调用总次数不超过 20000 次

代码：

#include<iostream>
#include<stack>
using namespace std;
class MinStack {
private:
    stack<int> stack[2];
public:
    /** initialize your data structure here. */
    MinStack() {
    }
    
    void push(int x) {
       stack[0].push(x);
       if(stack[1].empty()){
           stack[1].push(x);
       }else if(x<=stack[1].top()){
           stack[1].push(x);
       }
    }
    void pop() {
        int top = stack[0].top();
        stack[0].pop();
        if (stack[1].top() == top){
            stack[1].pop();
        }
    }
    int top() {
        return (stack[0].top());
    }
    int min() {
         return (stack[1].top());
    }
};

day02

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

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

代码：

/**
 * 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> res;
        while (head != NULL) {
            res.push_back(head->val);
            head = head->next;
        }
        reverse(res.begin(),res.end());
        return res;
    }
};

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

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

代码：

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
    ListNode* reverseList(ListNode* head) {
        ListNode* temp = head;
        head = NULL;
        while (temp != NULL) {
            ListNode* node = temp;
            temp = temp->next;
            node->next = head;
            head = node;
        }
        return head;
    }

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

11111111

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr) return nullptr;
        Node* cur = head;
        unordered_map<Node*, Node*> map;
        // 3. 复制各节点，并建立 “原节点 -> 新节点” 的 Map 映射
        while(cur != nullptr) {
            map[cur] = new Node(cur->val);
            cur = cur->next;
        }
        cur = head;
        // 4. 构建新链表的 next 和 random 指向
        while(cur != nullptr) {
            map[cur]->next = map[cur->next];
            map[cur]->random = map[cur->random];
            cur = cur->next;
        }
        // 5. 返回新链表的头节点
        return map[head];
    }
};

day03

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

示例 1：

输入：s = "We are happy."
输出："We%20are%20happy."

代码：

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

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

示例 1：

输入: s = "abcdefg", k = 2
输出: "cdefgab"
示例 2：

输入: s = "lrloseumgh", k = 6
输出: "umghlrlose"

代码：

#include<iostream>
#include<map>
#include<unordered_map>
using namespace std;
class Solution {
public:
    string reverseLeftWords(string s, int n) {
        this->swap(s, 0, n - 1);
        this->swap(s, n, s.length() - 1);
        this->swap(s, 0, s.length() - 1);
        return s;
    }
    void swap(string& s, int start, int end) {
        while (start < end) {
            char temp = s[start];
            s[start] = s[end];
            s[end] = temp;
            start++;
            end--;
        }
    }
};
int main() {
    string s = "abcdefg";
    Solution sol;
    string out = sol.reverseLeftWords(s, 2);
    cout << out << endl;
    return 0;
}

day04

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

示例 1：

输入：
[2, 3, 1, 0, 2, 5, 3]
输出：2 或 3

代码：

class Solution {
public:
    int findRepeatNumber(vector<int>& nums) {
        bool sign[100000] = { false };
        for (vector<int>::iterator i = nums.begin(); i < nums.end(); i++) {
            if (!sign[*i]) {
                sign[*i] = true;
            }
            else {
                return *i;
            }
        }
        return -1;
    }

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

示例 1:

输入: nums = [5,7,7,8,8,10], target = 8
输出: 2
示例 2:

输入: nums = [5,7,7,8,8,10], target = 6
输出: 0

#include<iostream>
#include<map>
#include<vector>
#include<unordered_map>
using namespace std;
class Solution {
public:
    int search(vector<int>& nums, int target) {
        int num = 0;
        int index = find(nums, 0, nums.size() - 1, target);
        if (index == -1) {
            return 0;
        }
        else {
            num++;
            int temp = index-1;
            while (temp >= 0 && nums[temp] == target) {
                num++;
                temp--;
            }
            temp = index+1;
            while (temp < nums.size()&& nums[temp] == target) {
                num++;
                temp++;
            }
            return num;
        }
    }
    int find(vector<int>& nums, int start, int end, int target) {
        if (start > end)
            return -1;
        int mid = (start + end) / 2;
        if (nums[mid] == target) {
            return mid;
        }
        else if (start == end) {
            return -1;
        }
        else if(nums[mid] < target) {
            return find(nums, mid + 1, end, target);
        }
        else {
            return find(nums,start, mid-1, target);
        }
    }
};
int main() {
    vector<int> nums;
    nums.push_back(1);
    nums.push_back(1);
    nums.push_back(2);
    Solution s;
    cout << s.search(nums, 1) << endl;
    return 0;
}

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

示例 1:

输入: [0,1,3]
输出: 2
示例 2:

输入: [0,1,2,3,4,5,6,7,9]
输出: 8

代码：

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        return find(nums, 0, nums.size()-1);
    }
    int find(vector<int>& nums,int start,int end) {
        if (start > end) {
            return -1;
        }
        else if (start == end) {
            return end;
        }
        int mid = (start + end) / 2;
        if (nums[mid] == mid) {
            return find(nums, mid + 1, end);
        }
        else {
            return find(nums, start, mid);
        }
    }
};

day05

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

示例:

现有矩阵 matrix 如下：

[
  [1,   4,  7, 11, 15],
  [2,   5,  8, 12, 19],
  [3,   6,  9, 16, 22],
  [10, 13, 14, 17, 24],
  [18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。

给定 target = 20，返回 false。

代码：

class Solution {
public:
    bool findNumberIn2DArray(vector<vector<int>>& matrix, int target) {
        bool sign = false;
        for (int i = 0; i < matrix.size(); i++) {
            if (findline(matrix[i], target, 0, matrix[i].size() - 1)) {
                sign = true;
            }
        }
        return sign;
    }

    bool findline(vector<int>& matrix, int target, int start,int end) {
        int mid = (start + end) / 2;
        if (start > end) {
            return false;
        }
        if (matrix[mid] == target) {
            return true;
        }
        else if (matrix[mid] < target) {
            return findline(matrix, target, mid + 1, end);
        }
        else {
            return findline(matrix, target,start, mid-1);
        }

    }
};

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。给你一个可能存在重复元素值的数组 numbers ，它原来是一个升序排列的数组，并按上述情形进行了一次旋转。请返回旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一次旋转，该数组的最小值为1。

示例 1：

输入：[3,4,5,1,2]
输出：1
示例 2：

输入：[2,2,2,0,1]
输出：0

代码：

class Solution {
public:
    int minArray(vector<int>& numbers) {
        return find(numbers, 0, numbers.size()-1)==-1?0:numbers[find(numbers, 0, numbers.size()-1)];
    }
    int find(vector<int>& numbers,int start,int end) {
        int mid = (start + end) / 2;
        if (start > end) {
            return -1;
        }
        if (start == end) {
            return start;
        }
        if (numbers[mid] > numbers[end]) {
            return find(numbers, mid+1, end);
        }
        else if (numbers[mid] < numbers[end]) {
            return find(numbers, start, mid);
        }
        else {
            return numbers[find(numbers, start, mid)] < numbers[find(numbers, mid + 1, end)]
                ? find(numbers, start, mid) : find(numbers, mid + 1, end);
        }

    }
};

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

示例 1:

输入：s = "abaccdeff"
输出：'b'
示例 2:

输入：s = "" 
输出：' '

代码：

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

day06

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

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回：

[3,9,20,15,7]

代码：

#include<iostream>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
using namespace std;
 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> res;
        queue<TreeNode*> que;
        if(root!=NULL)
            que.push(root);
        while (!que.empty()) {
            struct TreeNode* temp = que.front();
            res.push_back(temp->val);
            if (temp->left != NULL) {
                que.push(temp->left);
            }
            if (temp->right != NULL) {
                que.push(temp->right);
            }
            que.pop();
        }
        return res;
    }
};

int main() {
    TreeNode* root = new TreeNode(3);
    TreeNode* node9 = new TreeNode(9);
    TreeNode* node20 = new TreeNode(20);
    TreeNode* node15 = new TreeNode(15);
    TreeNode* node7 = new TreeNode(7);

    root->left = node9;
    root->right = node20;
    node20->left = node15;
    node20->right = node7;

    Solution s;
    vector<int> v=  s.levelOrder(root);
    for (auto i : v) {
        cout << i << " ";
    }
    return 0;
}

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

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

[
  [3],
  [9,20],
  [15,7]
]

代码：

#include<iostream>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
using namespace std;
 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
class Solution {
public:
    vector<vector<int>> level1rder(TreeNode* root) {
        vector<vector<int>> res;
        queue<TreeNode*> que;
        if (root == NULL)
            return res;
        que.push(root);
        que.push(NULL);
        vector<int>* resline = new vector<int>();
        while (!que.empty()) {
            struct TreeNode* temp = que.front();
            if (temp == NULL) {
                if(que.size()>1)
                    que.push(NULL);
                res.push_back(*resline);
                resline = new vector<int>();
            }
            else {
                resline->push_back(temp->val);
                if (temp->left != NULL) {
                    que.push(temp->left);
                }
                if (temp->right != NULL) {
                    que.push(temp->right);
                }
            }
            que.pop();
        }
        return res;
    }
};

int main() {
    TreeNode* root = new TreeNode(3);
    TreeNode* node9 = new TreeNode(9);
    TreeNode* node20 = new TreeNode(20);
    TreeNode* node15 = new TreeNode(15);
    TreeNode* node7 = new TreeNode(7);

    root->left = node9;
    root->right = node20;
    node20->left = node15;
    node20->right = node7;

    Solution s;
    vector<vector<int>> v=  s.level1rder(root);
    for (auto i : v) {
        for (auto j : i) {
            cout << j << " ";
        }
        cout << endl;
    }
    return 0;
}

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

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7
返回其层次遍历结果：

[
  [3],
  [20,9],
  [15,7]
]

代码：

#include<iostream>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
using namespace std;
 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>> res;
        queue<TreeNode*> que;
        bool sign = true;
        if (root == NULL)
            return res;
        que.push(root);
        que.push(NULL);
        vector<int>* resline = new vector<int>();
        while (!que.empty()) {
            struct TreeNode* temp = que.front();
            if (temp == NULL) {
                sign = !sign;
                if(que.size()>1)
                    que.push(NULL);
                res.push_back(*resline);
                resline = new vector<int>();
            }
            else {
                if (sign) {
                    resline->push_back(temp->val);
                }
                else {
                    resline->insert(resline->begin(),temp->val);
                }
                if (temp->left != NULL) {
                    que.push(temp->left);
                }
                if (temp->right != NULL) {
                    que.push(temp->right);
                }
            }
            que.pop();
        }
        return res;
    }
};

int main() {
    TreeNode* root = new TreeNode(3);
    TreeNode* node9 = new TreeNode(9);
    TreeNode* node20 = new TreeNode(20);
    TreeNode* node15 = new TreeNode(15);
    TreeNode* node7 = new TreeNode(7);

    root->left = node9;
    root->right = node20;
    node20->left = node15;
    node20->right = node7;

    Solution s;
    vector<vector<int>> v=  s.levelOrder(root);
    for (auto i : v) {
        for (auto j : i) {
            cout << j << " ";
        }
        cout << endl;
    }
    return 0;
}

day07

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

例如:
给定的树 A:

     3
    / \
   4   5
  / \
 1   2
给定的树 B：

   4 
  /
 1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。

代码：

#include<iostream>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
using namespace std;

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
class Solution {
public:

    bool isSubStructure(TreeNode* A, TreeNode* B) {
        if (B == NULL) {
            return false;
        }
        // 对A实行深度优先搜索
        queue<TreeNode*> que;
        que.push(A);
        while (!que.empty()) {
            TreeNode* temp = que.front();
            if (isSame(temp, B)) {
                return true;
            }
            else {
                if (temp->left != NULL) {
                    que.push(temp->left);
                }
                if (temp->right != NULL) {
                    que.push(temp->right);
                }
                que.pop();
            }
        }
        return false;
    }
    bool isSame(TreeNode* A, TreeNode* B) {
        
        if (B == NULL) {
            return true;
        }
        else {
            if (A == NULL) {
                return false;
            }
        }
        if (A->val != B->val) {
            return false;
        }
        else {
            if (isSame(A->left, B->left) && isSame(A->right, B->right)) {
                return true;
            }
            else {
                return false;
            }
        }
    }
};

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

例如输入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9
镜像输出：

     4
   /   \
  7     2
 / \   / \
9   6 3   1

代码：

 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;
         }
         else {
             mirrorTree(root->left);
             mirrorTree(root->right);
         }
         TreeNode* temp = root->right;
         root->right = root->left;
         root->left = temp;
         return root;
     }
 };

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

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。

    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:

    1
   / \
  2   2
   \   \
   3    3

代码：

#include<iostream>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
using namespace std;

 struct TreeNode {
     int val;
     TreeNode *left;
     TreeNode *right;
     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 };
 class Solution {
 public:
     bool isSymmetric(TreeNode* root) {
         if (root == NULL) {
             return true;
         }
         else {
             this->mirrorTree(root->right);
             return isSame(root->left, root->right);
         }
     }
     // 镜像树
     TreeNode* mirrorTree(TreeNode* root) {
         if (root == NULL) {
             return NULL;
         }
         else {
             mirrorTree(root->left);
             mirrorTree(root->right);
         }
         TreeNode* temp = root->right;
         root->right = root->left;
         root->left = temp;
         return root;
     }
     // 判断是否相等
     bool isSame(TreeNode* A, TreeNode* B) {
         if (A == NULL && B == NULL) {
             return true;
         }
         else if (A == NULL || B == NULL) {
             return false;
         }
         if (A->val != B->val) {
             return false;
         }
         else {
             if (isSame(A->left, B->left) && isSame(A->right, B->right)) {
                 return true;
             }
             else {
                 return false;
             }
         }
     }
 };


int main() {

 }

day08

写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

示例 1：

输入：n = 2
输出：1
示例 2：

输入：n = 5
输出：5

class Solution {
public:
    int fib(int n) {
        int  a =0;
        int b =1;
        int c=a+b;
        
        if(n==0)
            return 0;
        else if(n==1)
…        }
        return c;
    }
};

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

示例 1：

输入：n = 2
输出：2
示例 2：

输入：n = 7
输出：21
示例 3：

输入：n = 0
输出：1

class Solution {
public:
    int numWays(int n) {
        int a = 1, b = 1, sum;
        for(int i = 0; i < n; i++){
            sum = (a + b) % 1000000007;
            a = b;
            b = sum;
        }
        return a;
    }
};

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

示例 1:

输入: [7,1,5,3,6,4]
输出: 5
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
     注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
示例 2:

输入: [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
int length = prices.size();
int inf = 1e9;
        int minprice = inf, maxprofit = 0;
        for (int price: prices) {
            maxprofit = max(maxprofit, price - minprice);
            minprice = min(price, minprice);
        }
        return maxprofit;
    }
};

day09

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

示例1:

输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

代码：动态规划f(i)=max{f(i−1)+nums[i],nums[i]}

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int pre = 0, maxAns = nums[0];
        for (const auto& x : nums) {
            pre = max(pre + x, x);
            maxAns = max(maxAns, pre);
        }
        return maxAns;
    }
};

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

示例 1:

输入: 
[
  [1,3,1],
  [1,5,1],
  [4,2,1]
]
输出: 12
解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

代码：
111111

class Solution {
public:
 int maxValue(vector<vector<int>>& grid) {
        int sign[200][200] = {0};
        int m = grid.size();
        int n = grid[0].size();
        for (int i = 0; i < m ; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j == 0) {
                    sign[i][j] = grid[i][j];
…            }
        }
        return sign[m-1][n-1];
    }
};

day10

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

示例 1:

输入: 12258
输出: 5
解释: 12258有5种不同的翻译，分别是"bccfi", "bwfi", "bczi", "mcfi"和"mzi"

代码：

class Solution {
public:
    int translateNum(int num) {
        int n1 = num % 10;
        int n2 = num % 100;
        if(num<10){
            return 1;
        }
        if (n2 > 25||n1==n2) {
            return translateNum(num / 10);
        }
        else {
            return translateNum(num / 10) + translateNum(num / 100);
        }
    }
};

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

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

代码：

#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int max = 0;
        queue<char> que;
        int sign[200] = { 0 };
        for (int i = 0; i < s.length(); i++) {
            que.push(s[i]);
            int index = s[i];
            sign[index]++;

            while (sign[index] > 1) {
                int index2 = que.front();
                sign[index2]--;
                que.pop();
            }
            if (que.size() > max) {
                max = que.size();
            }
        }
        return max;
    }

};
int main() {
    Solution s;
    cout<<s.lengthOfLongestSubstring("   ");
}

day11

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

示例 1:

输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:

输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.

代码：

#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* deleteNode(ListNode* head, int val) {
        while (head->val==val) {
            head = head->next;
        }

        ListNode* temp = head->next;
        ListNode* pri = head;
        while (temp!= nullptr) {
            if (temp->val == val) {
                temp = temp->next;
                pri->next = temp;
            }
            else {
                temp = temp->next;
                pri = pri->next;
            }
        }
        return head;
    }
};
int main() {
    Solution s;
    ListNode* head = new ListNode(-3);
    ListNode* one = new ListNode(5);
    ListNode* two = new ListNode(-99);
    head->next = one;
    one->next = two;
    ListNode* temp = s.deleteNode(head,-3);
    while (temp != NULL) {
        cout << temp->val << " ";
        temp = temp->next;
    }
}

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

示例：

给定一个链表: 1->2->3->4->5, 和 k = 2.

返回链表 4->5.

代码：

#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        ListNode* one = head;
        ListNode* two = head;
        for (int i = 0; i < k; i++) {
            if (one == NULL) {
                return NULL;
            }
            else {
                one = one->next;
            }
        }
        while (one != NULL) {
            one = one->next;
            two = two->next;
        }
        return two;
    }
};
int main() {
    Solution s;
    ListNode* head = new ListNode(-3);
    ListNode* one = new ListNode(5);
    ListNode* two = new ListNode(-99);
    head->next = one;
    one->next = two;
    ListNode* temp = s.getKthFromEnd(head,2);
    while (temp != NULL) {
        cout << temp->val << " ";
        temp = temp->next;
    }
}

day12

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

示例1：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

#include<iostream>
#include<string>
#include<map>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;


struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
        ListNode* a = l1;
        ListNode* b = l2;
        ListNode* temp = new ListNode(0);
        ListNode* node = temp;
        while (a != NULL && b != NULL) {
            if (a->val <= b->val) {
                node->next = a;
                a = a->next;
            }
            else {
                node->next = b;
                b = b->next;
            }
            node = node->next;
        }
        if (a != NULL) {
            node->next = a;
        }
        if (b != NULL) {
            node->next = b;
        }
        return temp->next;
    }
};
int main() {
    Solution s;
    ListNode* l1 = new ListNode(1);
    ListNode* l2 = new ListNode(1);
    ListNode* l12 = new ListNode(2);
    ListNode* l13 = new ListNode(3);
    ListNode* l22 = new ListNode(4);
    ListNode* l23 = new ListNode(4);
    l1->next = l12;
    l12->next = l13;

    l2->next = l22;
    l22->next = l23;

    ListNode* temp = s.mergeTwoLists(l1,l2);
    while (temp != NULL) {
        cout << temp->val << " ";
        temp = temp->next;
    }
}

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

输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。


输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。

代码：

struct ListNode {
    int val;
    ListNode *next;
    ListNode(int x) : val(x), next(NULL) {}
};
class Solution {
public:
    ListNode* getIntersectionNode(ListNode* headA, ListNode* headB) {
        int numA = 0;
        int numB = 0;
        ListNode* a = headA;
        ListNode* b = headB;
        // 统计长度
        while (a != NULL) {
            numA++;
            a = a->next;
        }
        while (b != NULL) {
            numB++;
            b = b->next;
        }
        // 尾部对齐
        a = headA;
        b = headB;
        if (numA > numB) {
            for (int i = 0; i < numA - numB;i++) {
                a = a->next;
            }
        }
        else {
            for (int i = 0; i < numB-numA; i++) {
                b = b->next;
            }
        }
        // 比较
        ListNode* res = NULL;
        while (a != NULL) {

            if (a == b&&res==NULL) {
                res = a;
            }
            else if(a != b) {
                res = NULL;
            }


            a = a->next;
            b = b->next;
        }
        return res;
    }
};

day13

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

输入：nums = [1,2,3,4]
输出：[1,3,2,4] 
注：[3,1,2,4] 也是正确的答案之一。

代码：


class Solution {
public:
    vector<int> exchange(vector<int>& nums) {
        int i = 0;
        int j = nums.size() - 1;
        while (i != j&&i<j) {
            if (nums[i] % 2 == 0) {
                while (nums[j] % 2 == 0&&j>i){
                    j--;
                }
                int temp = nums[i];
                nums[i] = nums[j];
                nums[j] = temp;
            }
            i++;
        }
        return nums;
    }
};

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

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[2,7] 或者 [7,2]
示例 2：

输入：nums = [10,26,30,31,47,60], target = 40
输出：[10,30] 或者 [30,10]

代码：


class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> res;
        int i = 0;
        int j = nums.size()-1;
        while (i < j) {
            if (nums[i] + nums[j] == target) {
                res.push_back(nums[i]);
                res.push_back(nums[j]);
                return res;
            }
            else if (nums[i] + nums[j] < target) {
                i++;
            }
            else {
                j--;
            }
        }
        return res;
    }
};

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

示例 1：

输入: "the sky is blue"
输出: "blue is sky the"
示例 2：

输入: "  hello world!  "
输出: "world! hello"
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
示例 3：

输入: "a good   example"
输出: "example good a"
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

代码：

class Solution {
public:
    string reverseWords(string s) {
        stack<string> stc;
        string temp = "";
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == ' ') {
                if (temp.size() > 0) {
                    stc.push(temp);
                }
                temp = "";
            }
            else {
                temp += s[i];
            }
            if (s[i] != ' '&&i == s.size() - 1) {
                stc.push(temp);
                temp = "";
            }
        }
        string res = "";
        while (stc.size()>0) {
            res += stc.top();
            stc.pop();
            if (stc.size() > 0) {
                res += ' ';
            }
        }
        return res;
    }
};

双指针法：

class Solution {
public:
    string reverseWords(string s) {
        string res="";
        for (int j = s.size() - 1; j >= 0; j--) {
            if (s[j] != ' ') {
                int i = j - 1;
                while ( i >= 0 && s[i] != ' ')
                    i--;
                res += s.substr(i + 1, j - i);
                res += ' ';
                j = i;
            }
        }
        res.pop_back();
        return res;
    }
};

day14

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

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true
示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

代码：

#include<iostream>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#define MAX 200
using namespace std;

class Solution {
private:
    bool sign[MAX][MAX] = { false };
public:
    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 (search(board,word,i,j,0)) {
                    return true;
                }
            }
        }
        return false;
    }
    bool search(vector<vector<char>>& board, string word, int i,int j,int index) {
        int m = board.size();
        int n = board[0].size();
        // 当前不匹配，返回错，匹配则进行下一个选项匹配
        bool top = false;
        bool bottem = false;
        bool left = false;
        bool right = false;
        if (board[i][j] == word[index]) {
            // 匹配完成
            if (index+1 == word.size()) {
                return true;
            }
            this->sign[i][j] = true;
            // 上
            if (i>0&&this->sign[i-1][j]==false) {
                top = this->search(board, word, i - 1, j, index+1);
            }
            // 下
            if (i < m-1 && this->sign[i + 1][j] == false) {
                bottem = this->search(board, word, i + 1, j, index+1);
            }
            // 左
            if (j >0 && this->sign[i][j-1] == false) {
                left = this->search(board, word, i, j-1, index+1);
            }
            // 右
            if (j < n-1 && this->sign[i][j + 1] == false) {
                right = this->search(board, word, i, j + 1, index+1);
            }
            if (!(top | bottem | left | right)) {
                this->sign[i][j] = false;
            }
            return top | bottem | left | right;
        }
        else {
            return false;
        }
    }

};
int main() {
    Solution s;
//    string word = "ABCCED";
    string word = "AB";
    vector<vector<char>> board = { {'B','A'}};
//    vector<vector<char>> board = { {'A','B','C','E'},{'S','F','C','S'},{'A','D','E','E'} };
    cout << s.exist(board, word) << endl;
}

地上有一个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。请问该机器人能够到达多少个格子？

示例 1：

输入：m = 2, n = 3, k = 1
输出：3
示例 2：

输入：m = 3, n = 1, k = 0
输出：1

代码：

class Solution {
private:
    bool sign[100][100] = { false };
    int num = 0;
public:
    int movingCount(int m, int n, int k) {
        this->search(m,n,0, 0, k);
        return this->num;
    }
    void search(int m, int n, int i,int j,int k) {
        int sum = 0;
        // 统计
        int temp = i;
        while (temp!= 0) {
            sum += temp % 10;
            temp /= 10;
        }
        temp = j;
        while (temp != 0) {
            sum += temp % 10;
            temp /= 10;
        }
        if (sum <= k) {
            this->sign[i][j] = true;
            this->num++;
            // 上
            if (i > 0 && this->sign[i - 1][j] == false) {
                this->search(m, n, i - 1, j, k);
            }
            // 下
            if (i < m - 1 && this->sign[i + 1][j] == false) {
                this->search(m, n, i + 1, j, k);
            }
            // 左
            if (j > 0 && this->sign[i][j - 1] == false) {
                this->search(m, n, i, j - 1, k);
            }
            // 右
            if (j < n - 1 && this->sign[i][j + 1] == false) {
                this->search(m, n, i, j + 1, k);
            }
        }
    }
};

day15

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有从根节点到叶子节点路径总和等于给定目标和的路径。叶子节点是指没有子节点的节点。

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

输入：root = [1,2,3], targetSum = 5
输出：[]

代码：

#include<iostream>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;

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>> pathSum(TreeNode* root, int target) {
        vector<vector<int>> vec;
        vector<int> temp;
        this->findpath(vec, temp, root, target, 0);
        return vec;
    }
    void findpath(vector<vector<int>>& vec, vector<int> temp, TreeNode* root, int target, int sum) {
        if (root == nullptr)
            return;
        sum += root->val;
        if (sum == target && root->left == nullptr && root->right == nullptr) {
            temp.push_back(root->val);
            vec.push_back(temp);
        }
        temp.push_back(root->val);
        if (root->left != nullptr)
            this->findpath(vec, temp, root->left, target, sum);
        if (root->right != nullptr)
            this->findpath(vec, temp, root->right, target, sum);
    }
};
int main() {
    Solution s;
    TreeNode* root = new TreeNode(-2);
    TreeNode* root2 = new TreeNode(-3);
    root->right = root2;
    vector<vector<int>> a = s.pathSum(root, -5);
    for (auto i : a) {
        for (auto j : i) {
            cout << j << " ";
        }
        cout << endl;
    }
}

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

在这里插入图片描述

#include<iostream>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
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:
    Node* treeToDoublyList(Node* root) {
        queue<Node*> que;
        this->sort(root, que);
        if (que.size() > 0) {
            Node* head = que.front();
            Node* temp = head;
            que.pop();
            while (que.size() > 0) {
                Node* one = que.front();
                temp->right = one;
                one->left = temp;
                temp = temp->right;
                que.pop();
            }
            temp->right = head;
            head->left = temp;
            return head;
        }
        else {
            return nullptr;
        }
    }
    void sort(Node* root,queue<Node*> &que) {
        if (root == nullptr)
            return;
        if (root->left != nullptr) {
            this->sort(root->left, que);
        }
        que.push(root);
        if (root->right != nullptr) {
            this->sort(root->right, que);
        }
    }
};
int main() {
    Solution s;
}

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

示例 1:

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 4
示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 4

#include<iostream>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

class Solution {
public:
    int kthLargest(TreeNode* root, int k) {
        int num = 0;
        int number;
        vector<int> vec;
        this->find(root,vec);
        return vec[vec.size()-k];
    }
    void find(TreeNode* root, vector<int> &vec) {
        if (root == nullptr)
            return;
        if (root->left != nullptr) {
            this->find(root->left, vec);
        }
        vec.push_back(root->val);
        if (root->right != nullptr) {
            this->find(root->right, vec);
        }
    }
};
int main() {
    Solution s;
    TreeNode* root3 = new TreeNode(3);
    TreeNode* root1 = new TreeNode(1);
    TreeNode* root4 = new TreeNode(4);
    TreeNode* root2 = new TreeNode(2);

    root3->left = root1;
    root3->right = root4;
    root1->right = root2;

    cout << s.kthLargest(root3, 1) << endl;
}

day16

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

示例 1:

输入: [10,2]
输出: "102"
示例 2:

输入: [3,30,34,5,9]
输出: "3033459"

#include<iostream>
#include<string>
#include<map>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<math.h>
using namespace std;

class Solution {
public:
    string minNumber(vector<int>& nums) {
        // 排序
        for (int i = 0; i < nums.size()-1; i++) {
            for (int j = 0; j < nums.size() - i-1; j++) {
                if (this->bigger(nums[j],nums[j+1])) {
                    int temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
        string res;
        // 求和
        for (int i = 0; i < nums.size(); i++) {
            res += to_string(nums[i]);
        }
        return res;
    }

    // 统计位数
    int count(int num) {
        int count1 = 0;
        while (num != 0) {
            num /= 10;
            count1++;
        }
        return count1;
    }
    // 比较大小
    bool bigger(int num1, int num2) {      
        string a = to_string(num1);
        string b = to_string(num2);
        return a + b > b + a;
    }
};
int main() {
    Solution s;
    vector<int> nums = { 3,30,34,5,9 };
    cout << s.minNumber(nums) << endl;
}

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

示例 1:

输入: [1,2,3,4,5]
输出: True
 

示例 2:

输入: [0,0,1,2,5]
输出: True

代码：


```cpp
class Solution {
public:
    bool isStraight(vector<int>& nums) {
        sort(nums.begin(),nums.end());
        int count = 0;
        for (int i = 0; i < nums.size()-1; i++) {
            if (nums[i] == 0) {
                count++;
            }
            else {
…    }
};

day17

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

示例 1：

输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：

输入：arr = [0,1,2,1], k = 1
输出：[0]

代码：


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

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

例如，

[2,3,4] 的中位数是 3

[2,3] 的中位数是 (2 + 3) / 2 = 2.5

设计一个支持以下两种操作的数据结构：

void addNum(int num) - 从数据流中添加一个整数到数据结构中。
double findMedian() - 返回目前所有元素的中位数。
示例 1：

输入：
["MedianFinder","addNum","addNum","findMedian","addNum","findMedian"]
[[],[1],[2],[],[3],[]]
输出：[null,null,null,1.50000,null,2.00000]
示例 2：

输入：
["MedianFinder","addNum","findMedian","addNum","findMedian"]
[[],[2],[],[3],[]]
输出：[null,null,2.00000,null,2.50000]

代码：

#include<iostream>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<math.h>

using namespace std;
class MedianFinder {
public:
    multiset<int> set_arr;
    /** initialize your data structure here. */
    MedianFinder() {
        set_arr.clear();
    }

    void addNum(int num) {
        set_arr.insert(num);
    }
    double findMedian() {
        if (set_arr.size() == 0)
            return 0;
        set<int>::iterator itr = set_arr.begin();
        for (int i = 0; i < set_arr.size() / 2; i++) {
            itr++;
        }

        if (set_arr.size() % 2 == 0) {
            double res = 0;
            res += *itr;
            itr--;
            res += *itr;
            return res/2;
        }
        else {
            return *(itr);
        }
    }
};
int main() {
    MedianFinder* obj = new MedianFinder();
    obj->addNum(2);
    cout << obj->findMedian() << endl;
    obj->addNum(3);
    cout << obj->findMedian() << endl;
}

堆实现：

    // 维持堆数据平衡，并保证左边堆的最大值小于或等于右边堆的最小值
    void addNum(int num) {
        /*
         * 当两堆的数据个数相等时候，左边堆添加元素。
         * 采用的方法不是直接将数据插入左边堆，而是将数据先插入右边堆，算法调整后
         * 将堆顶的数据插入到左边堆，这样保证左边堆插入的元素始终是右边堆的最小值。
         * 同理左边数据多，往右边堆添加数据的时候，先将数据放入左边堆，选出最大值放到右边堆中。
         */
        if (maxHeap.size() == minHeap.size()) {
            minHeap.push(num);
            int top = minHeap.top();
            minHeap.pop();
            maxHeap.push(top);
        }
        else {
            maxHeap.push(num);
            int top = maxHeap.top();
            maxHeap.pop();
            minHeap.push(top);
        }
    }

    double findMedian() {
        if (maxHeap.size() == minHeap.size()) {
            return (maxHeap.top() + minHeap.top()) * 1.0 / 2;
        }
        else {
            return maxHeap.top() * 1.0;
        }
    }
};

day18

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

例如：

给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7
返回它的最大深度 3 。

代码：

class Solution {
private:
    int deep;
public:
    Solution() {
        deep = 0;
    }
    int maxDepth(TreeNode* root) {
        finddeep(root,0);
        return deep;
    }
    void finddeep(TreeNode* root,int index) {
        if (root != NULL) {
            index++;
            if (index > deep) {
                deep = index;
            }
            finddeep(root->left, index);
            finddeep(root->right, index);
        }
    }
};

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

示例 1:

给定二叉树 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7
返回 true 。

示例 2:

给定二叉树 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4
返回 false 。

代码：

class Solution {
public:
    bool isBalanced(TreeNode* root) {
        if (root == NULL) {
            return true;
        }
        else {
            if (abs(finddeep(root->left) - finddeep(root->right)) <= 1) {
                return isBalanced(root->left)&&isBalanced(root->right);
            }
            else {
                return false;
            }
        }
    }
    int abs(int a) {
        if (a >= 0)
            return a;
        else
            return -a;
    }
    int finddeep(TreeNode* root) {
        if (root == NULL) {
            return 0;
        }
        else {
            int left = finddeep(root->left);
            int right = finddeep(root->right);
            if (left > right) {
                return left + 1;
            }
            else {
                return right + 1;
            }
        }
    }
};

day19

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

示例 1：

输入: n = 3
输出: 6
示例 2：

输入: n = 9
输出: 45

代码：

class Solution {
public:
    int sumNums(int n) {
        return n==1?n:n+sumNums(n-1);
    }
};

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
输出: 6 
解释: 节点 2 和节点 8 的最近公共祖先是 6。
示例 2:

输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
输出: 2
解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

代码：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode* temp =  lowestCommonAncestor(root->left, p, q);
        if (temp!=nullptr) {
            return temp;
        }
        temp = lowestCommonAncestor(root->right, p, q);
        if (temp != nullptr) {
            return temp;
        }
        if (isFather(root, p, q)) {
            return root;
        }
        return nullptr;
    }
    bool isFather(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) {
            return false;
        }
        if (isSon(root, p) && isSon(root, q)) {
            return true;
        }
        else {
            return false;
        }
    }
    bool isSon(TreeNode* root, TreeNode* p) {
        if (root == nullptr) {
            return false;
        }
        if (root->val == p->val) {
            return true;
        }else if (root->val > p->val) {
            return isSon(root->left, p);
        }else{
            return isSon(root->right, p);
        }
    }
};

一次遍历：

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

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

示例 1:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输出: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:

输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。

代码：

class Solution {
public:
    TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) {
            return nullptr;
        }
        TreeNode* temp =  lowestCommonAncestor(root->left, p, q);
        if (temp!=nullptr) {
            return temp;
        }
        temp = lowestCommonAncestor(root->right, p, q);
        if (temp != nullptr) {
            return temp;
        }
        if (isFather(root, p, q)) {
            return root;
        }
        return nullptr;
    }
    bool isFather(TreeNode* root, TreeNode* p, TreeNode* q) {
        if (root == nullptr) {
            return false;
        }
        if (isSon(root, p) && isSon(root, q)) {
            return true;
        }
        else {
            return false;
        }
    }
    bool isSon(TreeNode* root, TreeNode* p) {
        if (root == nullptr) {
            return false;
        }
        if (root->val == p->val) {
            return true;
        }else {
            return isSon(root->left, p) || isSon(root->right, p);
        }
    }
};

day20

输入某二叉树的前序遍历和中序遍历的结果，请构建该二叉树并返回其根节点。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。

Input: preorder = [3,9,20,15,7], inorder = [9,3,15,20,7]
Output: [3,9,20,null,null,15,7]
示例 2:

Input: preorder = [-1], inorder = [-1]
Output: [-1]

代码：


class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0 || inorder.size() == 0 || preorder.size() != inorder.size()) {
            return nullptr;
        }
        int x = 0;
        return this->buildTree(preorder,x,inorder,0,inorder.size()-1);
    }
    TreeNode* buildTree(vector<int>& preorder, int &x, vector<int>& inorder, int start, int end) {
        // 超出界限返回空
        if (x > preorder.size() - 1) {
            return nullptr;
        }
        // 新建节点
        TreeNode* root = new TreeNode(preorder[x]);
        // 获取位置
        int index = getIndex(preorder[x],inorder,start,end);
        if (index >= start && index <= end) {
            root->left = buildTree(preorder, ++x, inorder, start, index - 1);
            root->right = buildTree(preorder, ++x, inorder, index + 1, end);
        }
        else {
            x--;
            return nullptr;
        }

        return root;
    }
    int getIndex(int val, vector<int>& inorder, int start, int end) {
        for (int i = start; i <= end; i++) {
            if (inorder[i] == val) {
                return i;
            }
        }
        return -1;
    }
};

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

示例 1：

输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：

输入：x = 2.10000, n = 3
输出：9.26100
示例 3：

输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25

代码：
快速幂：
在这里插入图片描述

class Solution {
public:
    double myPow(double x, int n) {
         if(n == 0) return 1;
        if(n == 1) return x;
        if(n == -1) return 1 / x;
        double half = myPow(x, n / 2);
        double mod = myPow(x, n % 2);
        return half * half * mod;
    }
};

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

示例 1：

输入: [1,6,3,2,5]
输出: false
示例 2：

输入: [1,3,2,6,5]
输出: true

代码：

class Solution {
public:
    bool verifyPostorder(vector<int>& postorder) {
        return isTrue(postorder, 0, postorder.size() - 1);
    }
    bool isTrue(vector<int>& postorder,int start,int end) {
        if (start == end||start>end) {
            return true;
        }
        int root = end;
        // 定位
        int newEnd = start;
        while (newEnd < end) {
            if (postorder[newEnd] > postorder[end]) {
                break;
            }
            newEnd++;
        }
        if (isTrue(postorder, start, newEnd-1) == false) {
            return false;
        }
        // 判断后一半是否符合
        int index = newEnd;
        while (index < end) {
            if (postorder[index] < postorder[end])
                return false;
            index++;
        }
        if (isTrue(postorder, newEnd, end - 1) == false) {
            return false;
        }
        return true;
    }
};

day21

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量).）。

示例 1：

输入：n = 11 (控制台输入 00000000000000000000000000001011)
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
示例 2：

输入：n = 128 (控制台输入 00000000000000000000000010000000)
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
示例 3：

输入：n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。

代码：

class Solution {
public:
    int hammingWeight(uint32_t n) {
        int num = 0;
        while (n != 0) {
            if ((n & 1) == 1) {
                num++;
            }
                n=n >> 1;
        }
        return num;
    }
};

写一个函数，求两个整数之和，要求在函数体内不得使用 “+”、“-”、“*”、“/” 四则运算符号。

示例:

输入: a = 1, b = 1
输出: 2

代码：

class Solution {
public:
    int add(int a, int b) {
         return b == 0 ? a : add(a ^ b, (a & b & 0x7fffffff) << 1);
    }
};

day22

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

示例 1：

输入：nums = [4,1,4,6]
输出：[1,6] 或 [6,1]
示例 2：

输入：nums = [1,2,10,4,1,4,3,3]
输出：[2,10] 或 [10,2]

代码：

class Solution {
public:
    vector<int> singleNumbers(vector<int>& nums) {
        set<int> se;
        for (int i = 0; i < nums.size(); i++) {
            int oldnum = se.size();
            se.insert(nums[i]);
            if (oldnum == se.size()) {
                set<int>::iterator itr =  se.find(nums[i]);
                se.erase(itr);
            }
        }
        vector<int> res;
        for (auto i : se) {
            res.push_back(i);
        }
        return res;
    }
};

位运算：
先对所有数字进行一次异或，得到两个出现一次的数字的异或值。
在异或结果中找到任意为 1的位。
根据这一位对所有的数字进行分组。
在每个组内进行异或操作，得到两个数字。

class Solution {
public:
    vector<int> singleNumbers(vector<int>& nums) {
        int ret = 0;
        for (int n : nums)
            ret ^= n;
        int div = 1;
        while ((div & ret) == 0)
            div <<= 1;
        int a = 0, b = 0;
        for (int n : nums)
            if (div & n)
                a ^= n;
            else
                b ^= n;
        return vector<int>{a, b};
    }
};

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

示例 1：

输入：nums = [3,4,3,3]
输出：4
示例 2：

输入：nums = [9,1,7,9,7,9,7]
输出：1

class Solution {
public:
    int singleNumber(vector<int>& nums) {
int ones = 0, twos = 0;
        for(int num : nums){
            ones = ones ^ num & ~twos;
            twos = twos ^ num & ~ones;
        }
        return ones;
    }
};

day23

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

示例 1:

输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2

代码：

class Solution {
public:
    int majorityElement(vector<int>& nums) {
        stack<int> sta;
        for (int i = 0; i < nums.size(); i++) {
            if (sta.empty()) {
                sta.push(nums[i]);
            }
            else if (sta.top() == nums[i]) {
                sta.push(nums[i]);
            }
            else {
                sta.pop();
            }
        }
        return sta.top();
    }
};

给定一个数组 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]。不能使用除法。

示例:

输入: [1,2,3,4,5]
输出: [120,60,40,30,24]

代码：

class Solution {
public:
    vector<int> constructArr(vector<int>& a) {
        vector<int> res;
        vector<int> tempRes;
        int temp = 1;
        for (int i = 0; i < a.size(); i++) {
            res.push_back(temp);
            temp *= a[i];
        }
        temp = 1;
        for (int i = a.size()-1; i >=0 ; i--) {
            tempRes.push_back(temp);
            temp *= a[i];
        }
        for (int i = 0; i < a.size(); i++) {
            res[i] *= tempRes[a.size() - i - 1];
        }
        return res;
    }
};

day24

给你一根长度为 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。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

代码：


class Solution {
public:
    int cuttingRope(int n) {
        if (n == 2) {
            return 1;
        }
        int dp[59];
        for (int i = 1; i <= n; i++) {
            if (i == 1) {
                dp[i] = 1;
            }
            else {
                dp[i] = 0;
                for (int j = 1; j < i; j++) {
                    if (j * dp[i - j] > dp[i]) {
                        dp[i] = j * dp[i - j];
                    }
                }
                if(i!=n&&(dp[i]<i)){
                    dp[i] = i;
                }
            }
        }
        return dp[n];
    }
};

输入一个正整数 target ，输出所有和为 target 的连续正整数序列（至少含有两个数）。序列内的数字由小到大排列，不同序列按照首个数字从小到大排列。

示例 1：

输入：target = 9
输出：[[2,3,4],[4,5]]
示例 2：

输入：target = 15
输出：[[1,2,3,4,5],[4,5,6],[7,8]]

代码：

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        vector<vector<int>> res;
        int head = 1;
        int bottom = 2;
        int sum = head+bottom;
        if ((target == 1) || (target == 2)) {
            return res;
        }
        while (head != bottom) {
            if (sum < target) {
                bottom++;
                sum += bottom;
            }else if(sum > target){
                sum -= head;
                head++;
            }
            else {
                res.push_back(this->returnNN(head, bottom));
                sum -= head;
                head++;
            }
        }

        return res;
    }
    vector<int> returnNN(int i, int j) {
        vector<int> temp;
        for (int m = i; m <= j; m++) {
            temp.push_back(m);
        }
        return temp;
    }
};

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

示例 1：

输入: n = 5, m = 3
输出: 3
示例 2：

输入: n = 10, m = 17
输出: 2

代码：

class Solution {
    int f(int n, int m) {
        if (n == 1) {
            return 0;
        }
        int x = f(n - 1, m);
        return (m + x) % n;
    }
public:
    int lastRemaining(int n, int m) {
        return f(n, m);
    }
};

day25

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

示例 1：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

代码：

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        vector<int> res;
        if (matrix.size() == 0) {
            return res;
        }
        int m = matrix.size();
        int n = matrix[0].size();
        int temp = 0;
        int i = 0, j = 0;

        while (j + temp < n-temp && i + temp < m-temp) {
            while (j+temp < n-temp) {
                res.push_back(matrix[i+temp][j+temp]);
                j++;
            }
            i++;
            j--;
            if (!(i + temp < m - temp)) {
                break;
            }
            while (i+temp < m-temp) {
                res.push_back(matrix[i+temp][j+temp]);
                i++;
            }
            j--;
            i--;
            if (!(j + temp >= temp)) {
                break;
            }
            while (j+temp >= temp) {
                res.push_back(matrix[i+temp][j+temp]);
                j--;
            }
            i--;
            j++;
            if (!(i + temp > temp)) {
                break;
            }
            while (i+temp >temp ) {
                res.push_back(matrix[i+temp][j+temp]);
                i--;
            }
            i = 0; j = 0;
            temp++;
        }
        return res;
    }
};

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

示例 1：

输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2：

输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。

代码：

class Solution {
public:
    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
        stack<int> stack;
        int i = 0;
        for (int num : pushed) {
            stack.push(num); // num 入栈
            while (!stack.empty() && stack.top() == popped[i]) { // 循环判断与出栈
                stack.pop();
                i++;
            }
        }
        return stack.empty();
    }
};

day26

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

数值（按顺序）可以分成以下几个部分：

若干空格
一个小数或者整数
（可选）一个 ‘e’ 或 ‘E’ ，后面跟着一个整数
若干空格
小数（按顺序）可以分成以下几个部分：

（可选）一个符号字符（’+’ 或 ‘-’）
下述格式之一：
至少一位数字，后面跟着一个点 ‘.’
至少一位数字，后面跟着一个点 ‘.’ ，后面再跟着至少一位数字
一个点 ‘.’ ，后面跟着至少一位数字
整数（按顺序）可以分成以下几个部分：

（可选）一个符号字符（’+’ 或 ‘-’）
至少一位数字
部分数值列举如下：

["+100", “5e2”, “-123”, “3.1416”, “-1E-16”, “0123”]
部分非数值列举如下：

[“12e”, “1a3.14”, “1.2.3”, “±5”, “12e+5.4”]

示例 1：

输入：s = "0"
输出：true
示例 2：

输入：s = "e"
输出：false
示例 3：

输入：s = "."
输出：false

代码：

有穷自动机
111

class Solution {
public:
    enum State {
        STATE_INITIAL,
        STATE_INT_SIGN,
        STATE_INTEGER,
        STATE_POINT,
        STATE_POINT_WITHOUT_INT,
        STATE_FRACTION,
        STATE_EXP,
        STATE_EXP_SIGN,
        STATE_EXP_NUMBER,
        STATE_END
    };

    enum CharType {
        CHAR_NUMBER,
        CHAR_EXP,
        CHAR_POINT,
        CHAR_SIGN,
        CHAR_SPACE,
        CHAR_ILLEGAL
    };

    CharType toCharType(char ch) {
        if (ch >= '0' && ch <= '9') {
            return CHAR_NUMBER;
        } else if (ch == 'e' || ch == 'E') {
            return CHAR_EXP;
        } else if (ch == '.') {
            return CHAR_POINT;
        } else if (ch == '+' || ch == '-') {
            return CHAR_SIGN;
        } else if (ch == ' ') {
            return CHAR_SPACE;
        } else {
            return CHAR_ILLEGAL;
        }
    }

    bool isNumber(string s) {
        unordered_map<State, unordered_map<CharType, State>> transfer{
            {
                STATE_INITIAL, {
                    {CHAR_SPACE, STATE_INITIAL},
                    {CHAR_NUMBER, STATE_INTEGER},
                    {CHAR_POINT, STATE_POINT_WITHOUT_INT},
                    {CHAR_SIGN, STATE_INT_SIGN}
                }
            }, {
                STATE_INT_SIGN, {
                    {CHAR_NUMBER, STATE_INTEGER},
                    {CHAR_POINT, STATE_POINT_WITHOUT_INT}
                }
            }, {
                STATE_INTEGER, {
                    {CHAR_NUMBER, STATE_INTEGER},
                    {CHAR_EXP, STATE_EXP},
                    {CHAR_POINT, STATE_POINT},
                    {CHAR_SPACE, STATE_END}
                }
            }, {
                STATE_POINT, {
                    {CHAR_NUMBER, STATE_FRACTION},
                    {CHAR_EXP, STATE_EXP},
                    {CHAR_SPACE, STATE_END}
                }
            }, {
                STATE_POINT_WITHOUT_INT, {
                    {CHAR_NUMBER, STATE_FRACTION}
                }
            }, {
                STATE_FRACTION,
                {
                    {CHAR_NUMBER, STATE_FRACTION},
                    {CHAR_EXP, STATE_EXP},
                    {CHAR_SPACE, STATE_END}
                }
            }, {
                STATE_EXP,
                {
                    {CHAR_NUMBER, STATE_EXP_NUMBER},
                    {CHAR_SIGN, STATE_EXP_SIGN}
                }
            }, {
                STATE_EXP_SIGN, {
                    {CHAR_NUMBER, STATE_EXP_NUMBER}
                }
            }, {
                STATE_EXP_NUMBER, {
                    {CHAR_NUMBER, STATE_EXP_NUMBER},
                    {CHAR_SPACE, STATE_END}
                }
            }, {
                STATE_END, {
                    {CHAR_SPACE, STATE_END}
                }
            }
        };

        int len = s.length();
        State st = STATE_INITIAL;

        for (int i = 0; i < len; i++) {
            CharType typ = toCharType(s[i]);
            if (transfer[st].find(typ) == transfer[st].end()) {
                return false;
            } else {
                st = transfer[st][typ];
            }
        }
        return st == STATE_INTEGER || st == STATE_POINT || st == STATE_FRACTION || st == STATE_EXP_NUMBER || st == STATE_END;
    }
};

把字符串转换成整数
写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。
首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。
当我们寻找到的第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字组合起来，作为该整数的正负号；假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成整数。
该字符串除了有效的整数部分之后也可能会存在多余的字符，这些字符可以被忽略，它们对于函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换。
在任何情况下，若函数不能进行有效的转换时，请返回 0。
说明：
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231, 231 − 1]。如果数值超过这个范围，请返回 INT_MAX (231 − 1) 或 INT_MIN (−231) 。

class Solution {
public:
    int strToInt(string str) {
        if (str.size() == 0) return 0;

        

        int res = 0, bndry = 2147483647 / 10;
        int i = 0, sign = 1;

        while (str[i] == ' ') {
            i++;
        }
        if (str[i] == '-') {
            sign = -1;
            i++;
        }
        else if (str[i] == '+') {
            i++;
        }

        for (int j = i; j < str.size(); j++) {
            if (str[j] < '0' || str[j] > '9') 
                break;

            if (res > bndry ||( res == bndry && str[j] > '7'))
                return sign == 1 ? 2147483647: -2147483648;
            res = res * 10 + (str[j] - '0');
        }
        return sign * res;
    }
};

day27

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

示例:

输入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
输出: [3,3,5,5,6,7] 
解释: 

  滑动窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

代码：

#include<iostream>
#include<string>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<math.h>
using namespace std;

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        int length = nums.size();
        if (length == 0) {
            return res;
        }
        int maxIndex = 0;
        
        // 开始滑动窗口
        int i = 0;
        while (i+k<=length){

            if (maxIndex<i||i==0) {
                maxIndex = i;
                // 查找第一个最大的数
                for (int j = i; j < i+k; j++) {
                    if (nums[j] > nums[maxIndex]) {
                        maxIndex = j;
                    }
                }
            }
            else {
                if (nums[i + k - 1] > nums[maxIndex]) {
                    maxIndex = i + k - 1;
                }
            }
            // 添加到数组中
            res.push_back(nums[maxIndex]);
            i++;
        }
        return res;
    }
};


int main() {
    Solution s;
    vector<int> nums = {1, 3, -1, -3, 5, 3, 6, 7};
    int k = 3;
    vector<int> res = s.maxSlidingWindow(nums, k);
    for (auto i : res) {
        cout << i << " ";
    }
}

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

示例 1：

输入: 
["MaxQueue","push_back","push_back","max_value","pop_front","max_value"]
[[],[1],[2],[],[],[]]
输出: [null,null,null,2,1,2]
示例 2：

输入: 
["MaxQueue","pop_front","max_value"]
[[],[],[]]
输出: [null,-1,-1]

代码：

class MaxQueue {
private:
    queue<int> que;
    deque<int> maxQue;
public:
    MaxQueue() {
    }

    int max_value() {
        if (que.size() == 0) {
            return -1;
        }
        return maxQue.front();
    }
    void push_back(int value) {
        que.push(value);
        if (maxQue.empty()) {
            maxQue.push_back(value);
        }
        else {
            while (!maxQue.empty()&&maxQue.back() < value) {
                maxQue.pop_back();
            }
            maxQue.push_back(value);
        }
    }

    int pop_front() {
        if (que.size() == 0) {
            return -1;
        }
        if (maxQue.front() == que.front()) {
            maxQue.pop_front();
        }
        int value = que.front();
        que.pop();
        return value;
    }
};

day28

请实现两个函数，分别用来序列化和反序列化二叉树。你需要设计一个算法来实现二叉树的序列化与反序列化。这里不限定你的序列 / 反序列化算法执行逻辑，你只需要保证一个二叉树可以被序列化为一个字符串并且将这个字符串反序列化为原始的树结构。提示：输入输出格式与 LeetCode 目前使用的方式一致，详情请参阅 LeetCode 序列化二叉树的格式。你并非必须采取这种方式，你也可以采用其他的方法解决这个问题。

struct TreeNode {
	int val;
	TreeNode* left;
	TreeNode* right;
	TreeNode(int x) : val(x), left(NULL), right(NULL) {}
	
};

class Codec {
public:
    void rserialize(TreeNode* root, string& str) {
        if (root == nullptr) {
            str += "None,";
        }
        else {
            str += to_string(root->val) + ",";
            rserialize(root->left, str);
            rserialize(root->right, str);
        }
    }

    string serialize(TreeNode* root) {
        string ret;
        rserialize(root, ret);
        return ret;
    }

    TreeNode* rdeserialize(list<string>& dataArray) {
        if (dataArray.front() == "None") {
            dataArray.erase(dataArray.begin());
            return nullptr;
        }

        TreeNode* root = new TreeNode(stoi(dataArray.front()));
        dataArray.erase(dataArray.begin());
        root->left = rdeserialize(dataArray);
        root->right = rdeserialize(dataArray);
        return root;
    }

    TreeNode* deserialize(string data) {
        list<string> dataArray;
        string str;
        for (auto& ch : data) {
            if (ch == ',') {
                dataArray.push_back(str);
                str.clear();
            }
            else {
                str.push_back(ch);
            }
        }
        if (!str.empty()) {
            dataArray.push_back(str);
            str.clear();
        }
        return rdeserialize(dataArray);
    }
};
int main() {
    Codec codec;
    TreeNode* root1 = new TreeNode(-1);
    TreeNode* root2 = new TreeNode(2);
    TreeNode* root3 = new TreeNode(3);
    TreeNode* root4 = new TreeNode(4);
    TreeNode* root5 = new TreeNode(5);

    root1->left = root2;
    root1->right = root3;
    root3->left = root4;
    root3->right = root5;
    cout << codec.serialize(root1) << endl;
    cout << codec.serialize(codec.deserialize(codec.serialize(root1))) << endl;
}

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

示例:
输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]

class Solution {
public:
    vector<string> permutation(string s) {
        dfs(s, 0);
        return res;
    }
private:
    vector<string> res;
    void dfs(string s, int x) {
        if(x == s.size() - 1) {
            res.push_back(s);                       // 添加排列方案
            return;
        }
        set<int> st;
        for(int i = x; i < s.size(); i++) {
            if(st.find(s[i]) != st.end()) continue; // 重复，因此剪枝
            st.insert(s[i]);
            swap(s[i], s[x]);                       // 交换，将 s[i] 固定在第 x 位
            dfs(s, x + 1);                          // 开启固定第 x + 1 位字符
            swap(s[i], s[x]);                       // 恢复交换
        }
    }
};

day29

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

输入:
s = "aa"
p = "a"
输出: false
解释: "a" 无法匹配 "aa" 整个字符串。
示例 2:

输入:
s = "aa"
p = "a*"
输出: true
解释: 因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此，字符串 "aa" 可被视为 'a' 重复了一次。
示例 3:

输入:
s = "ab"
p = ".*"
输出: true
解释: ".*" 表示可匹配零个或多个（'*'）任意字符（'.'）。
示例 4:

输入:
s = "aab"
p = "c*a*b"
输出: true
解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。
示例 5:

输入:
s = "mississippi"
p = "mis*is*p*."
输出: false

动态规划算法：

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

        auto matches = [&](int i, int j) {
            if (i == 0) {
                return false;
            }
            if (p[j - 1] == '.') {
                return true;
            }
            return s[i - 1] == p[j - 1];
        };

        vector<vector<int>> f(m + 1, vector<int>(n + 1));
        f[0][0] = true;
        for (int i = 0; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (p[j - 1] == '*') {
                    f[i][j] |= f[i][j - 2];
                    if (matches(i, j - 1)) {
                        f[i][j] |= f[i - 1][j];
                    }
                }
                else {
                    if (matches(i, j)) {
                        f[i][j] |= f[i - 1][j - 1];
                    }
                }
            }
        }
        return f[m][n];
    }
};

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

示例:

输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数

代码：
要得到从小到大的第 nn 个丑数，可以使用最小堆实现。初始时堆为空。首先将最小的丑数 11 加入堆。每次取出堆顶元素 xx，则 xx 是堆中最小的丑数，由于 2x, 3x, 5x2x,3x,5x 也是丑数，因此将 2x, 3x, 5x2x,3x,5x 加入堆。上述做法会导致堆中出现重复元素的情况。为了避免重复元素，可以使用哈希集合去重，避免相同元素多次加入堆。在排除重复元素的情况下，第 nn 次从最小堆中取出的元素即为第 nn 个丑数。

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> factors = { 2, 3, 5 };
        unordered_set<long> seen;
        priority_queue<long, vector<long>, greater<long>> heap;
        seen.insert(1L);
        heap.push(1L);
        int ugly = 0;
        for (int i = 0; i < n; i++) {
            long curr = heap.top();
            heap.pop();
            ugly = (int)curr;
            for (int factor : factors) {
                long next = curr * factor;
                if (!seen.count(next)) {
                    seen.insert(next);
                    heap.push(next);
                }
            }
        }
        return ugly;
    }
};

动态规划：

class Solution {
public:
    int nthUglyNumber(int n) {
       vector<int> dp(n + 1);
        dp[1] = 1;
        int p2 = 1, p3 = 1, p5 = 1;
        for (int i = 2; i <= n; i++) {
            int num2 = dp[p2] * 2, num3 = dp[p3] * 3, num5 = dp[p5] * 5;
            dp[i] = min(min(num2, num3), num5);
            if (dp[i] == num2) {
…    }
};

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

示例 1:

输入: 1
输出: [0.16667,0.16667,0.16667,0.16667,0.16667,0.16667]
示例 2:

输入: 2
输出: [0.02778,0.05556,0.08333,0.11111,0.13889,0.16667,0.13889,0.11111,0.08333,0.05556,0.02778]

代码：
在这里插入图片描述

class Solution {
public:
    vector<double> dicesProbability(int n) {
        vector<double> dp(6, 1.0 / 6.0);
        for (int i = 2; i <= n; i++) {
            vector<double> tmp(5 * i + 1, 0);
            for (int j = 0; j < dp.size(); j++) {
                for (int k = 0; k < 6; k++) {
                    tmp[j + k] += dp[j] / 6.0;
                }
            }
            dp = tmp;
        }
        return dp;
    }
};

day30

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

示例 1:

输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]

class Solution {
public:
    int reversePairs(vector<int>& nums) {
        int len = nums.size();
        vector<int> temp(len);
        return this->find(nums, temp, 0, len - 1);
    }
    int find(vector<int>& nums, vector<int>& temp,int left,int right) {
        // 递归终点
        if (left >= right) {
            return 0;
        }
        int mid = left + (right - left) / 2;
        int count = find(nums, temp, left, mid) + find(nums, temp, mid + 1, right);
        // 开始归并排序（从小到大排列）
        int i = left;
        int j = mid + 1;
        int index = left;
        while (i <= mid && j <= right) {
            if (nums[i] <= nums[j]) {
                temp[index] = nums[i];
                i++;
                // 后半段都比num[i]大
                count += (j - mid - 1);
            }
            else {
                temp[index] = nums[j];
                j++;
            }
            index++;
        }
        for (int k = i; k <= mid; ++k) {
            temp[index++] = nums[k];
            count += (j - (mid + 1));
        }
        for (int k = j; k <= right; ++k) {
            temp[index++] = nums[k];
        }
        copy(temp.begin() + left, temp.begin() + right + 1, nums.begin() + left);
        return count;
    }
};

day31

给你一根长度为 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。

示例 1：

输入: 2
输出: 1
解释: 2 = 1 + 1, 1 × 1 = 1
示例 2:

输入: 10
输出: 36
解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36

代码：

class Solution {
public:
    int cuttingRope(int n) {
        if (n <= 3) return n - 1;
        long res = 1L;
        int p = (int)1e9 + 7;
        //贪心算法，优先切三，其次切二
        while (n > 4) {
            res = res * 3 % p;
            n -= 3;
        }
        //出来循环只有三种情况，分别是n=2、3、4
        return (int)(res * n % p);
    }
};

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

示例 1：

输入：n = 12
输出：5
示例 2：

输入：n = 13
输出：6

在这里插入图片描述

代码：

class Solution {
public:
    int countDigitOne(int n) {
  double digit = 1, res = 0;
        int high = n / 10, cur = n % 10, low = 0;
        while(high != 0 || cur != 0) {
            if(cur == 0) res += high * digit;
            else if(cur == 1) res += high * digit + low + 1;
            else res += (high + 1) * digit;
            low += cur * digit;
            cur = high % 10;
            high /= 10;
            digit *= 10;
        }
        return res;
    }
};

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

示例 1：

输入：n = 3
输出：3
示例 2：

输入：n = 11
输出：0

代码：

class Solution {
public:
    int findNthDigit(int n) {
        int sign = 1;
        while (n>(pow(10,sign)- (sign == 1 ? 0 : pow(10, sign - 1)))*sign-1) {
            n -= (pow(10,sign)- (sign == 1 ? 0 : pow(10, sign - 1)))*sign;
                sign++;
        }
        int res = sign==1?0:pow(10, sign - 1);
        res += (n+1) / sign-1;
        if ((n+1) % sign == 0) {
            return res % 10;
        }
        else {
            res++;
            int temp = pow(10, sign - (n +1)% sign);
            return res / temp % 10;
        }
    }
};