LeetCode每周刷题总结2.27-3.5

第二周力扣记录总结：

232. 用栈实现队列

232. 用栈实现队列
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
解题思路：
利用两个栈不断塞进其中一个的顶端，来模拟队列pop().其余与stack差别不大。

class MyQueue {
private:
     stack<int> stackout,stackin;
        
    void in2out(){
        while(!stackin.empty())
        {
            stackout.push(stackin.top());
            stackin.pop();
        }
      }
    
    
public:
    MyQueue() {}
   
    
    void push(int x) {
      stackin.push(x);  
    }
    
    int pop() {
        if(stackout.empty())
        {
            in2out();
        }
        int x = stackout.top();
        stackout.pop();
        return x;
    }
    
    int peek() {
    if(stackout.empty())
    {
        in2out();
    }
        return stackout.top();
    }
    
    bool empty() {
    
        return stackout.empty()&&stackin.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

94. 二叉树的中序遍历

94. 二叉树的中序遍历
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
解题思路：
中序遍历：左、根、右
其余就是递归了。

示例 1： 输入：root = [1,null,2,3] 输出：[1,3,2] 示例 2： 输入：root = [] 输出：[] 示例 3： 输入：root = [1] 输出：[1]

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void inorder(TreeNode * root,vector<int>&res)
    {
         if (!root)
            return;
        inorder(root->left,res);
        res.push_back(root->val);
        inorder(root->right,res);
    }
    vector<int> inorderTraversal(TreeNode* root) {
       vector<int>res;
        inorder(root,res);
        return res;
    }
};

144. 二叉树的前序遍历

144. 二叉树的前序遍历
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
解题思路：
如上题类似，前序遍历：根、左、右

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> v;
    vector<int> preorderTraversal(TreeNode* root) {
        if(root!=nullptr)
        {   
            v.push_back(root->val);
            preorderTraversal(root->left);
            preorderTraversal(root->right);
        }
        return v;
    }
};

145. 二叉树的后序遍历

145. 二叉树的后序遍历
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
解题思路：根、左、右+递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void postorder(TreeNode* root,vector<int>&res )
    {
        if(root==nullptr)
        {
            return;
        }
        postorder(root->left,res);
        postorder(root->right,res);
        res.push_back(root->val);
    }
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        postorder(root,res);
        return res;
    }
};

101. 对称二叉树

101. 对称二叉树
给你一个二叉树的根节点 root ， 检查它是否轴对称。

输入：root = [1,2,2,3,4,4,3]
输出：true
解题思路：左右对称即左右节点的值相等，递归判断左右两边值就行。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
 
class Solution {
public:
    bool check(TreeNode* u, TreeNode* v)
    {
        queue<TreeNode*> q;
        q.push(u),q.push(v);
        while(!q.empty())
        {
            u=q.front(),q.pop();
            v=q.front(),q.pop();
            if(!u&&!v)
                continue;
            if((!u||!v)||u->val!=v->val)
                return false;
            q.push(u->left);
            q.push(v->right);
            
            q.push(u->right);
            q.push(v->left);
                
        }
        return true;
    }
    bool isSymmetric(TreeNode* root) {
        return check(root,root);
    }
};

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

剑指 Offer 10- I. 斐波那契数列
写一个函数，输入 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。
解题思路：经典题不再过多讲解，记得取模就行，我忘记取模wa了两发…

class Solution {
public:
    int fib(int n) {
        int MOD = 1000000007;
        if (n < 2) {
            return n;
        }
        int p = 0, q = 0, r = 1;
        for (int i = 2; i <= n; ++i) {
            p = q; 
            q = r; 
            r = (p + q)%MOD;
        }
        return r;
    }
};

2575. 找出字符串的可整除数组

2575. 找出字符串的可整除数组
给你一个下标从 0 开始的字符串 word ，长度为 n ，由从 0 到 9 的数字组成。另给你一个正整数 m 。

word 的 可整除数组 div 是一个长度为 n 的整数数组，并满足：

如果 word[0,…,i] 所表示的 数值 能被 m 整除，div[i] = 1
否则，div[i] = 0
返回 word 的可整除数组。
解题思路：
我们可以从左到右扫描字符串 word，记录当前所扫描的前缀代表的数值 mod m 的余数。具体地，假设当前扫描到了下标 i，我们可以通过如下公式计算前缀代表的数值 mod m 的余数： num = (num * 10 + (word[i] - '0')) % m 其中，num 表示当前扫描到的前缀代表的数值 mod m 的余数。 然后，我们可以根据 num 是否为 0，确定 div[i] 的值。如果 num 为 0，说明当前前缀代表的数值能够被 m 整除，因此 div[i] 的值为 1；否则，div[i] 的值为 0。 最后返回 div 数组即可。

class Solution {
public:
    vector<int> divisibilityArray(string word, int m) {
        int n = word.size();
        vector<int> div(n, 0);
        long long num = 0;
        for (int i = 0; i < n; i++) {
            num = (num * 10 + (word[i] - '0')) % m;
            if (num == 0) {
                div[i] = 1;
            }
        }
        return div;
    }
};

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

剑指 Offer 22. 链表中倒数第k个节点
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
解题思路：for循环遍历 链表有多少节点，最后输出从k开始的节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* getKthFromEnd(ListNode* head, int k) {
        int n = 0;
        ListNode* node =nullptr;
        for(node = head;node;node=node->next)// 学到了链表是这样遍历的
        {
            n++;
        }
        for(node=head;n>k;n--)
        {
             node=node->next;
        }
        return node;
    }
};

104. 二叉树的最大深度

104. 二叉树的最大深度
给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。
解题思路：递归统计。需要注意的是根节点深度为1。需要额外加1。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root==nullptr)
        return 0;
        
        return max(maxDepth(root->left),maxDepth(root->right))+1;
    }
};

110. 平衡二叉树

110. 平衡二叉树

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。
解题思路：递归计算左子树和右子树的高度 不能超过1就行。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int MaxDepth(TreeNode* root){
         if(root==nullptr){
             return 0;
         }
        return max(MaxDepth(root->left),MaxDepth(root->right))+1;
    }
    bool isBalanced(TreeNode* root) {
        if(root==nullptr)
        {
            return true;
        }
        return abs(MaxDepth(root->left)-MaxDepth(root->right))<=1&&isBalanced(root->left)&&isBalanced(root->right);
    }
};

226. 翻转二叉树

226. 翻转二叉树
给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
解题思路：递归遍历左右子树，并交换左右子树的值。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==nullptr)
        return nullptr;
        TreeNode* left = invertTree(root->left);
        TreeNode* right = invertTree(root->right);
        root->left=right;
        root->right=left;
        return root;
    }
};

912 排序数组

没用特别高明的方式 直接sort排序了。

class Solution {
public:
    vector<int> sortArray(vector<int>& nums) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        return nums;
    }
};