LeetCode 110平衡二叉树 257.二叉树的所有路径 404左叶子之和

110平衡二叉树

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

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

一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：true

示例 2：

输入：root = [1,2,2,3,3,null,null,4,4]
输出：false

示例 3：

输入：root = []
输出：true

提示：

• 树中的节点数在范围 [0, 5000] 内
• -104 <= Node.val <= 104

c++ 代码实现

/**
 * 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:
    // 递归三要素
    // 1.函数参数
    int getHeight(TreeNode *node) {
        // 停止条件
        if (node == nullptr) return 0;

        int leftH = getHeight(node->left);
        // 是否已超过 1 
        if (leftH == -1) return -1;

        int rightH = getHeight(node->right);
        // 是否已超过 1 
        if (rightH == -1) return -1;

        // 高度差是否超过 1 。大于返回 -1
        if (abs(leftH - rightH) > 1) {
            return -1;
        }else{
            // 计算当前最大
            return 1 + max(leftH, rightH);
        }
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true; 
    }
};

python 代码实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getHeight(self, root):
        if not root:
            return 0
        
        lh = self.getHeight(root.left)
        if lh == -1:
            return -1
        rh = self.getHeight(root.right)
        if rh == -1:
            return -1

        if abs(lh - rh) > 1:
            return -1
        else:
            return (1 + max(lh, rh))

    def isBalanced(self, root: Optional[TreeNode]) -> bool:
        if self.getHeight(root) == -1:
            return False
        else:
            return True

257.二叉树的所有路径

给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [1,2,3,null,5]
输出：["1->2->5","1->3"]

示例 2：

输入：root = [1]
输出：["1"]

提示：

• 树中节点的数目在范围 [1, 100] 内
• -100 <= Node.val <= 100

c++代码实现

/**
 * 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 path(TreeNode * node, vector<int>& pathVec, vector<string>& sPath) {
        // 最后也要加入
        pathVec.push_back(node->val);
        // 停止条件
        if (node->left == nullptr && node->right == nullptr) {
            // 组合字符串
            string str;
            for (int i = 0 ; i < pathVec.size() - 1; i++) {
                str += to_string(pathVec[i]);
                str += "->";
            }
            str += to_string(pathVec[pathVec.size() - 1]);
            sPath.push_back(str);
            return;
        }
        // 单次遍历
        if (node->left) {
            path(node->left, pathVec, sPath);
            // 回溯
            pathVec.pop_back();
        }
        if (node->right) {
            path(node->right, pathVec, sPath);
            pathVec.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> pathVec;
        vector<string> sPath;
        path(root, pathVec, sPath);
        return sPath;
    }
};

python 代码实现

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def __init__(self):
        self.intPath = []
        self.strPath = []
    def path(self, node):
        self.intPath.append(node.val)
        # 停止条件
        if not node.left and not node.right:
            # 组合字符串
            s = ""
            for i in range(len(self.intPath)-1):
                s += str(self.intPath[i])
                s += "->"
            s += str(self.intPath[len(self.intPath) - 1])
            self.strPath.append(s)
            return

        if node.left:
            self.path(node.left)
            self.intPath.pop()
        if node.right:
            self.path(node.right)
            self.intPath.pop()

    def binaryTreePaths(self, root: Optional[TreeNode]) -> List[str]:
        self.path(root)
        return self.strPath

404左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

示例 1：

输入: root = [3,9,20,null,null,15,7] 
输出: 24 
解释: 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24

示例 2:

输入: root = [1]
输出: 0

提示:

• 节点数在 [1, 1000] 范围内
• -1000 <= Node.val <= 1000

c++ 代码实现

/**
 * 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 leaves(TreeNode * node) {
        // 停止条件
        if (node == nullptr) return 0;
        if (node->left == nullptr && node->right == nullptr) return 0;

        // 计算
        int leftVal = leaves(node->left);
        // 左叶子不为空，但是其左右孩子为空，就是最后的左叶子
        TreeNode * curNode = node->left;
        if (curNode != nullptr &&curNode->left == nullptr && curNode->right == nullptr) {
            leftVal = curNode->val;
        }

        // 计算
        int rightVal = leaves(node->right);
        int sum = leftVal + rightVal;
        return sum;
    }
    int sumOfLeftLeaves(TreeNode* root) {
        return leaves(root);
    }
};

python 代码

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        if not root:
            return 0
        
        if not root.left and not root.right:
            return 0
        
        lsum = self.sumOfLeftLeaves(root.left)
        if root.left != None and root.left.left == None and root.left.right==None:
            lsum = root.left.val
        
        rsum = self.sumOfLeftLeaves(root.right)
        return (lsum + rsum)