代码随想录算法训练营day17| 110.平衡二叉树，257. 二叉树的所有路径，404.左叶子之和

110.平衡二叉树

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 {
public:
    /*
    二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
    二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。
    */
    int getHeight(TreeNode* node){
        //空节点高度为0
        if(node==NULL) return 0;
        //后序遍历 左右中
        int leftheight = getHeight(node->left);
        if(leftheight==-1) return -1;
        int rightheight = getHeight(node->right);
        if(rightheight==-1) return -1;
        //中
        int ans;
        if(abs(leftheight-rightheight)>1) return -1;
        else{
            ans = 1+max(leftheight, rightheight);
        }
        return ans;

    }

    bool isBalanced(TreeNode* root) {
        int ans = getHeight(root);
        return ans==-1? false:true;
    }
};

257. 二叉树的所有路径

257. 二叉树的所有路径
 

<algorithm>

/**
 * 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 traversal(TreeNode* node, vector<int>& path, vector<string>& ans){
        //中
        path.push_back(node->val);
        //终止条件
        if(node->left==NULL && node->right==NULL){
            string spath;
            for(int i=0; i<path.size()-1; i++){
                spath += to_string(path[i]);
                spath += "->";
            }
            spath += to_string(path[path.size()-1]);
            ans.push_back(spath);
            return;
        }

        //左右
        if(node->left){
            traversal(node->left, path, ans);
            path.pop_back();
        } 
        if(node->right){
            traversal(node->right, path, ans);
            path.pop_back();
        }

    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> ans;
        traversal(root, path, ans);
        return ans;
    }
};

404.左叶子之和

404. 左叶子之和

通过节点的父节点来判断其左孩子是不是左叶子。

如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子

/**
 * 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 traversal(TreeNode* node){
        if(node==NULL) return 0;
        if(node->left==NULL && node->right==NULL) return 0;

        //后序遍历
        //左
        int left = traversal(node->left);
        //通过节点的父节点来判断其左孩子是不是左叶子。
        //如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子
        if(node->left!=NULL && node->left->left==NULL
        && node->left->right==NULL){
            left = node->left->val;
        }

        //右
        int right = traversal(node->right);
        //中
        int sum = left + right;
        return sum;

    }
    int sumOfLeftLeaves(TreeNode* root) {
        int ans;
        ans = traversal(root);
        return ans;
    }
};