代码随想录|day17|二叉树----110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和

 全部链接：腾讯文档

 110. 平衡二叉树

链接：代码随想录

/**
 * 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 {
//每个节点 的左右两个子树的高度差的绝对值不超过 1 
public:
    bool flag=true;
    bool isBalanced(TreeNode* root) {
       int t=helper(root);
       return flag;
    }

    int helper(TreeNode *root)
    {
        if(root==nullptr)
        {
            return 0;
        }
        else if(root->left==nullptr && root->right==nullptr)
        {
            return 1;
        }
        int left_depth=helper(root->left);
        int right_depth=helper(root->right);
        //cout<<left_depth<<"      "<<right_depth<<endl;
        if(abs(left_depth-right_depth)>1)
        {
            flag=false;
        }
        return max(left_depth,right_depth)+1;

    }
};

257. 二叉树的所有路径

链接：代码随想录

这道题用到了回溯+递归，值得思考。

 

解法第一种：自己的写法和弊端

/**
 * 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 {
//二叉树所有路径，有弊端的写法
//int 转string https://blog.csdn.net/hyqwmxsh/article/details/72288767
public:
    vector<string>v;
    string s="";
    vector<string> binaryTreePaths(TreeNode* root) {
        if(root==nullptr)
        {
            return v;
        }
        dfs(root);
       
        return v;
    }
    void dfs(TreeNode *root)
    {
        if(root!=nullptr)
        {
            if(root->left==nullptr && root->right==nullptr)//叶子节点
            {
                int len=s.size();
                s+=to_string(root->val);
                v.push_back(s);
                //s=s.substr(0,len);//回溯
            }
            else
            {
                int len=s.size();
                 s+=to_string(root->val);
                 s+="->";
                dfs(root->left);
                dfs(root->right);
                s=s.substr(0,len);//回溯
            }
        }
    }
};

如果叶子节点不回溯，会出现（错误代码）

 报错例子：

第二种解法，优化后：

/**
 * 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<string>v;
    vector<int>path;
    vector<string> binaryTreePaths(TreeNode* root) {
        if(root==nullptr)
        {
            return v;
        }
        dfs(root,path);
        return v;
        

    }
    void dfs(TreeNode *root,vector<int> &path)
    {
        if(root!=nullptr)
        {
            if(root->left==nullptr && root->right==nullptr)//终止条件：到达叶子节点
            {
                string s="";
                for(int i=0;i<path.size();i++)
                {
                    s+=to_string(path[i]);
                    s+="->";
                }
                s+=to_string(root->val);
                v.push_back(s);
            }
            else
            {
                //非叶子节点
                path.push_back(root->val);
                dfs(root->left,path);
                 dfs(root->right,path);
                path.pop_back();
            }
        }
    }
};

  404.左叶子之和

链接：代码随想录

注意：一开始没有思路，想直接用层序遍历算每一层最左侧的值，但是那种应该是左视图，左叶子的重要定义：

左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

则

没有左叶子

 

 

 所以判断是否为左叶子的重要逻辑：

if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
    左叶子节点处理逻辑
}

本题代码：

解法一：

/**
 * 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) {

        return dfs(root);

    }
    int dfs(TreeNode *root)
    {
        if(root==nullptr)return 0;

        //对于左子树，如果左子树就是一个叶子，则left_sum==左叶子，否则left_sum等于左子树中所有左叶子的和
       
        //后序遍历，顺序不能颠倒！否则如果root节点left是一个左叶子就结束遍历了
         int left_sum=dfs(root->left);
         if(root->left!=nullptr && root->left->left==nullptr && root->left->right==nullptr)
         {
          left_sum= root->left->val;
         }
         int right_sum=dfs(root->right);

         return left_sum+right_sum;




    }

};

解法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:
    int sum=0;
    int sumOfLeftLeaves(TreeNode* root) {
        Dfs(root);
        return sum;

    }
    void Dfs(TreeNode* root)
    {
        if(root!=nullptr)
        {
            if(root->left!=nullptr && root->left->left==nullptr &&  root->left->right==nullptr)
            {
                sum+=root->left->val;
            }
            Dfs(root->left);
            Dfs(root->right);
        }
    }
};