代码随想录算法训练营Day15||Leecode110.平衡二叉树、Leecode257.二叉树所有路径、Leecode404.左叶子总和、Leecode222.完全二叉树节点个数

一、平衡二叉树

        开心，又是一道自己做AC的题目，并且我的做法和题解的思路还不太一样，虽然麻烦一点，但是是由自己思考过后想到的多巴胺直接拉满~

        在做这题的时候，一开始bool 函数内没有考虑小子树的情况，只比较了两颗大子树。所以会有部分样例不通过

        

        我的做法：

/**
 * 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*Startnode){
        TreeNode*node=Startnode;
        if(node==nullptr)return 0;
        int leftmaxdepth=maxdepth(node->left);
        int rightmaxdepth=maxdepth(node->right);
        int maxresult=1+max(leftmaxdepth,rightmaxdepth);
        return maxresult;
    }
    bool isBalanced(TreeNode* root) {
        TreeNode*node=root;
        if(root==nullptr)return true;
        if(abs(maxdepth(root->left)-maxdepth(root->right))>1)return false;
        bool isleft=isBalanced(node->left);
        bool isright=isBalanced(node->right);
        return isleft&&isright;
    }
};

二、二叉树所有路径

        首先要定义一个path数组要记录节点数（先不管->），递归三部曲第一步：返回值为0，传参有开始遍历的节点、path数组、result数组。第二步：终止条件是遍历到叶子节点（判断叶子节点的方法是看一个节点的左指针和右指针同时为空即为叶子）第三步：单层循环的代码是把节点值传入path数组中，在每一轮到遍历到叶子节点时，要用to_string函数把path中的int变量变成string类型存放进sPath这个变量中，这个变量把整条路径都保存下来以后再加入到result数组中。本题在遍历左、右节点的时候，要加一个pop_back回溯，124,125，126诸如此类，把2后面的所有节点都能遍历到

        

/**
 * 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 travelsal(TreeNode*root,vector<int>&path,vector<string>&result){
     
       
        path.push_back(root->val);
        
        if(root->left==nullptr&&root->right==nullptr){
           
            string sPath;
            for(int i=0;i<path.size()-1;i++){//这里要小于size-1，最后一个元素单独加入，因为循环内包括->的添加
                sPath+=to_string(path[i]);
                sPath+="->";
            }
            sPath+=to_string(path[path.size()-1]);
            result.push_back(sPath);
            return;
        }

        if(root->left){
            travelsal(root->left,path,result);
            path.pop_back();
            
        }
        if(root->right){
            travelsal(root->right,path,result);
            path.pop_back();
            
        }

   
    }

    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string>result;
        vector<int>path;
        
        
        if(root==nullptr)return result;
        travelsal(root,path,result);
        return result;
    }
};

 三、左叶子节点之和

        递归三部曲：第一步 确定返回值为int，参数是传入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:

    
    int sumOfLeftLeaves(TreeNode* root) {
        TreeNode*startnode=root;
        if(startnode==nullptr)return 0;
        if(startnode->left==nullptr&&startnode->right==nullptr)return 0;
        
        int lefts=sumOfLeftLeaves(startnode->left);
        if(startnode->left!=nullptr&&startnode->left->left==nullptr&&startnode->left->right==nullptr)
        lefts=startnode->left->val;
        int rights=sumOfLeftLeaves(startnode->right);
        int sum=lefts+rights;
        return sum;   
    }
};

四、完全二叉树的节点个数

        层序遍历秒了~

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

        return returnsize;
    }
};

 递归做法：

/**
 * 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 countNodes(TreeNode* root) {
        TreeNode*cur=root;
        if(cur==nullptr)return 0;
        int leftsum=countNodes(cur->left);
        int rightsum=countNodes(cur->right);
        int sum=leftsum+rightsum+1;
        return sum;
    }
};

总体思路就是左子树所有的节点数+右子树所有节点数+自身节点数1，遇到空节点记为0