代码随想录算法训练营第十六天 | LeetCode 104、559、111、222

---

前言

LeetCode题目：LeetCode 104、559、111、222
Takeaway：和昨天的内容基本差不多，甚至有一样的题，还是标准的，要理解各种二叉树遍历的放法(先、中、后、层序遍历)，以及递归三部曲：先确定返回值和参数，再确定递归出口，最后是每层的递归处理。

---

一、104

昨天就做过的题，没什么好说的，使用队列进行层序遍历就能轻松解决。

/**
 * 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) {
        queue<TreeNode*> que;
        if(root != NULL){
            que.push(root);
        }
        TreeNode* cur = root;

        int resLevel = 0;

        while(que.size() != 0){

            resLevel++;

            // 这个size用的非常好，可以使用size来确定每层多少个元素
            int size = que.size();
            
            for(int i=0;i<size;i++){
                cur = que.front();
                que.pop();
                
                if(cur->left!=NULL){
                    que.push(cur->left);
                }
                if(cur->right!=NULL){
                    que.push(cur->right);
                }
            }
            
        }

        return resLevel;
    }
};

---

二、559

和上一道题的逻辑一模一样，唯一的区别是这次遍历所有子节点，而不是只有两个子节点。

/*
// Definition for a Node.
class Node {
public:
    int val;
    vector<Node*> children;

    Node() {}

    Node(int _val) {
        val = _val;
    }

    Node(int _val, vector<Node*> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
public:
    int maxDepth(Node* root) {
        queue<Node*> que;
        if(root != NULL){
            que.push(root);
        }
        Node* cur = root;

        int resLevel = 0;

        while(que.size() != 0){

            resLevel++;

            // 这个size用的非常好，可以使用size来确定每层多少个元素
            int size = que.size();
            
            for(int i=0;i<size;i++){
                cur = que.front();
                que.pop();
                
                for(int i=0; i<cur->children.size(); i++){
                    que.push(cur->children[i]);
                }
            }
        }
        return resLevel;
    }
};

---

三、111

仍然是昨天就做过的题，和第一题一个路子就能做出来，第一题是找到底为止，这个是找到第一次没有左右子节点就为止。

/**
 * 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 minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if(root != NULL){
            que.push(root);
        }
        TreeNode* cur = root;

        int resLevel = 0;

        while(que.size() != 0){

            resLevel++;

            // 这个size用的非常好，可以使用size来确定每层多少个元素
            int size = que.size();
            
            for(int i=0;i<size;i++){
                cur = que.front();
                que.pop();
                
                if(cur->left!=NULL){
                    que.push(cur->left);
                }
                if(cur->right!=NULL){
                    que.push(cur->right);
                }
                
                // 最浅就在这
                if(cur->left == NULL && cur->right ==NULL){
                    return resLevel;
                }
            }
        }
        return resLevel;
    }
};

---

四、222

这题是今天这四道题里面唯一一个没做过的，但仍然比较简单(我真不知道这个凭什么是middle，kmp却是easy？)，最简单的解法就是不考虑它是完全二叉树，而是按照它是普通二叉树的逻辑来做，递归会非常好写。但是这里我的解法是考虑到题里给出的：这棵树是完全二叉树的解法，相对复杂一点点，主要是递归出口有点多，别的都没什么。

/**
 * 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 sum;

    int findNodes(TreeNode* root) {
        if(root == NULL){
            return 0;
        }
        int leftDepth = 0;
        int rightDepth = 0;

        TreeNode* cur = root;

        while(cur!=NULL){
            cur = cur->left;
            leftDepth++;
        }

        while(cur!=NULL){
            cur = cur->right;
            rightDepth++;
        }

        if(leftDepth == rightDepth){
            return pow(2, leftDepth+1)-1;
        }

        // 上面全是递归出口，下面才是内部逻辑
        else{
            int leftNum = findNodes(root->left);
            int rightNum = findNodes(root->right);
            return leftNum+rightNum+1;
        }
    }

    int countNodes(TreeNode* root) {
        int sum = findNodes(root);
        return sum;
    }
};

---

总结

昨天刷的多了，今天很多题都是重复的，所以比较简单就搞定了，非要说有什么进步，那就是递归写的越来越流畅了，递推的思路也清晰了。