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

目录

一、110. 平衡二叉树

1.题目描述

2.解题思路

3.代码实现

二、257. 二叉树的所有路径

1.题目描述

2.解题思路

3.代码实现

三、404. 左叶子之和

1.题目描述

2.解题思路

3.代码实现

---

 

一、110. 平衡二叉树

1.题目描述

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

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

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

示例 1：

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

示例 2：

输入：root = []
输出：true

2.解题思路

平衡二叉树的定义：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过 1 

• 1.明确递归函数的参数和返回值：定义一个函数getHeight（node）用来计算二叉树高度：其中，计算高度采用的是后序遍历。
• 2.明确终止条件：①如果node是NULL，return 0,空节点的高度为0。②判断左右子树是否为平衡二叉树，如果不是，返回  -1。
• 3.明确单层递归逻辑：如果左右子树的高度差绝对值大于1，return -1。否则，返回给上一层节点的高度。

3.代码实现

/**
 * 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){//1.获取这个节点的高度
        //计算高度：后序遍历，左、右、中
        if(node == NULL)    return 0;
        int result;//保存返回的结果值

        //开始判断左右子树是否为平衡二叉树
        int leftHeight = getHeight(node->left);
        if(leftHeight == -1)    return -1;//如果左子树不是二叉平衡树，那么返回给上一层

        int rightHeight = getHeight(node->right);
        if(rightHeight == -1)   return -1;

        //此时，左右子树是平衡二叉树，判断整体是否为平衡二叉树
        //如果左右子树高度差绝对值超过1，说明不是平衡二叉树，用-1来标记
        if(abs(leftHeight - rightHeight) > 1)   result = -1;
        else{
            //说明左右子树是平衡二叉树，那么返回这个数的高度
            result = 1 + max(leftHeight,rightHeight);
        }   
        return result;

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

二、257. 二叉树的所有路径

1.题目描述

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

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

 

示例 1：

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

示例 2：

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

2.解题思路

• 前序遍历：中、左、右
• path存放路径上的节点值，然后遇到叶子结点，就将path数组转化成string存放到结果集中，然后进行回溯，将path最后一个节点值pop出去。

3.代码实现

/**
 * 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.确定函数参数和返回值：参数1-root，参数2-记录遍历的节点值（vector），参数3-记录结果集(vector)
    void traversal(TreeNode* node,vector<int>& path,vector<string>& result){
        //采用前序遍历
        //中，因为终止条件是左右孩子节点为NULL，如果写在下面，那么最后一个节点就没有添加到path中
        path.push_back(node->val);
        //2.确定递归终止条件：当前节点为叶子结点
        if(node->left == NULL && node->right == NULL){
            //就开始将当前路径存入到结果集中
            //将path转化成string存入
            string stemp;
            for(int i = 0;i < path.size() - 1;i++){
                stemp += to_string(path[i]);
                stemp += "->";
            }
            stemp += to_string(path[path.size() - 1]);
            result.push_back(stemp);//存入结果集
            return;
        }
        //3.开始单层递归逻辑
        if(node->left){
            //左孩子树不为空,就对左孩子树进行超级操作
            traversal(node->left,path,result);
            //回溯操作:遍历到叶子节点后，需要将path中最后一个节点值pop出来，进行回溯
            path.pop_back();
        }
        if(node->right){
            traversal(node->right,path,result);
            path.pop_back();
        }

    }

    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;//记录路径上的节点值
        vector<string> result;//存放结果集
        traversal(root,path,result);
        return result;
    }
};

三、404. 左叶子之和

1.题目描述

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

示例 1：

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

示例 2:

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

2.解题思路

• 必须是叶子节点，
• 必须是父节点的左孩子
• 开始递归，如果是NULL，直接return 0。如果左右孩子是NULL，也直接return 0 
• 分别计算左右孩子树的左叶子节点之和，其中，如果节点的左孩子是叶子节点，就累加这个叶子结点的val。

3.代码实现

/**
 * 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 leftNum = traversal(node->left);
        if(node->left && node->left->left == NULL && node->left->right == NULL)
            leftNum += node->left->val;
        //右
        int rightNum = traversal(node->right);
        //中
        return leftNum + rightNum;
    }

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