Day17｜二叉树part04：110.平衡二叉树、257.二叉树的所有路径、404.左叶子之和

最新推荐文章于 2024-07-10 11:04:17 发布

QHG7C0

最新推荐文章于 2024-07-10 11:04:17 发布

阅读量66

点赞数

分类专栏：数据结构与算法（一刷）文章标签：算法

本文链接：https://blog.csdn.net/weixin_43303286/article/details/131982632

版权

数据结构与算法（一刷）专栏收录该内容

60 篇文章 3 订阅

订阅专栏

leetcode链接：力扣题目链接(opens new window)

视频链接：后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树 (opens new window)

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

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

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

示例 1：

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

这题和求二叉树的最大深度（某节点到根节点的距离）那题有点类似，但求的是高度（某节点到叶子节点的距离），**每个节点子树的高度差都不超过1。**适合用递归法。为了统一，新增一个递归函数getHeight。

确定递归函数的参数和返回值

参数：当前传入节点。返回值：以当前传入节点为根节点的树的高度。

那么如何标记左右子树是否差值大于1呢？

如果当前传入节点为根节点的二叉树已经不是二叉平衡树了，还返回高度的话就没有意义了。

所以如果已经不是二叉平衡树了，可以返回-1 来标记已经不符合平衡树的规则了。

代码如下：当我们发现任何一个节点不符合时，向上直接返回-1，直接到根节点返回false

// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node)

确定递归的终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0

代码如下：

if (node == NULL) {
    return 0;
}

确定单层的递归逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

后序遍历左右中（这里的左右中我觉得就是分别对左右中进行处理，不单单是打印这么简单）

int leftHeight = getHeight(node->left); // 左
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right); // 右
if (rightHeight == -1) return -1;

//如果左右子树的子树都符合，左右子树对于该节点来说不一定符合
int result;
if (abs(leftHeight - rightHeight) > 1) {  // 中
    result = -1;
} else {
    result = 1 + max(leftHeight, rightHeight); // 以当前节点为根节点的树的最大高度
}

return result;

精简后的getHeight函数如下：

int getHeight(TreeNode* node) {
    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;
    return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
}

整体的题解如下：

class Solution {
public:
    // 返回以该节点为根节点的二叉树的高度，如果不是平衡二叉树了则返回-1
    int getHeight(TreeNode* node) {
        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;
        return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

257. 二叉树的所有路径（回溯的初登场）

leetcode链接：力扣题目链接(opens new window)

视频链接：递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径 (opens new window)

从现在开始一刷了，能看懂回溯的思路但想不出这么写代码，第一眼想起来用栈。

先使用递归法，由于路径是从根到叶子的，所以使用前序遍历根左右。并创建一个新的函数traverse()进行遍历。

确定函数参数和返回值

要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值，代码如下：

void traversal(TreeNode* cur, vector<int>& path, vector<string>& result)//&引用运算符

确定递归终止条件

遍历到叶子节点时终止：那么什么时候算是找到了叶子节点？ 是当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。

所以本题的终止条件是：

if (cur->left == NULL && cur->right == NULL) { // 遇到叶子节点
    string sPath;
    for (int i = 0; i < path.size() - 1; i++) { // 将path里记录的路径转为string格式
        sPath += to_string(path[i]);
        sPath += "->";
    }
    sPath += to_string(path[path.size() - 1]); // 记录最后一个节点（叶子节点）
    result.push_back(sPath); // 收集一个路径
    return;
}

找到叶子结点之后将int数组改成string类型push到result中。

确定单层递归逻辑

path.push_back(node->val);//中
//左
if(node->left != nullptr){
  traversal(node->left,path,result);
  path.pop_back();//回溯的过程
}
if(node->right != nullptr){
  traversal(node->right,path,result);
  path.pop_back();//回溯的过程
}

这里最好把递归和回溯写到一起！我们知道，回溯和递归是一一对应的，有一个递归，就要有一个回溯，这么写的话相当于把递归和回溯拆开了，一个在花括号里，一个在花括号外。

所以回溯要和递归永远在一起，世界上最遥远的距离是你在花括号里，而我在花括号外！

最终的我写的代码：

class Solution {
public:
    void traversal(TreeNode* cur, vector<int> &path, vector<string> &result){
        path.push_back(cur->val);
        if(cur->left != nullptr){
            traversal(cur->left,path,result);
            path.pop_back();//回溯的过程
        }
        if(cur->right != nullptr){
            traversal(cur->right,path,result);
            path.pop_back();//回溯的过程
        }
        if(cur->left == nullptr && cur->right == nullptr){
            string sPath = "";
            for(int i = 0; i < path.size() ; i++){
                sPath += to_string(path[i]);
                if(i != path.size() - 1){
                    sPath += "->";
                }
            }
            result.push_back(sPath);
        }

    }

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

精简版本：

class Solution {
private:

    void traversal(TreeNode* cur, string path, vector<string>& result) {
        path += to_string(cur->val); // 中
        if (cur->left == NULL && cur->right == NULL) {
            result.push_back(path);
            return;
        }
        if (cur->left) traversal(cur->left, path + "->", result); // 左
        if (cur->right) traversal(cur->right, path + "->", result); // 右
    }

public:
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        string path;
        if (root == NULL) return result;
        traversal(root, path, result);
        return result;

    }
};

表面上看这个没有回溯，实际上是有回溯的，就在traversal(cur->left, path + “->”, result)这一步，传进去是path + “->”，实际上path并没有变，也是一种回溯。

404. 左叶子之和

leetcode链接：力扣题目链接(opens new window)

视频链接：二叉树的题目中，总有一些规则让你找不到北 | LeetCode：404.左叶子之和 (opens new window)

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

**示例 1：**

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

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

第一眼想到的层次遍历的迭代法，问题是这么判断左叶子？一上来就被卡哥打了个脸。首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。

这里给出左叶子的明确定义：

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

所以判断是不是左叶子，需要考虑其父节点的情况。也就是遍历上一个节点时，才能判断其孩子是否符合要求。所以这里应该用什么遍历？后序遍历。

确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int。本来使用题目中的函数就可以了，但为了遍历框架，我重新设计一个函数sumLeaves:

int sumLeaves(TreeNode* cur) {

确定终止条件

如果遍历到空节点，那么左叶子值一定是0

if (cur == NULL) return 0;

还有一种情况：遍历到叶子节点的，并不知道叶子结点是不是我们想要的左叶子，故遇到叶子节点时也返回0

if(cur->left == nullptr && cur->right == nullptr){
  return 0;
}

确定单层递归的逻辑

int leftValue = sumOfLeftLeaves(root->left);    // 左
if (root->left && !root->left->left && !root->left->right) {
    leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right);  // 右

int sum = leftValue + rightValue;               // 中
return sum;