题目解析

主要的思路是借助于求树的深度，首先想到的就是新建一个辅助函数，求深度的。但是这个时候我就摇摆不定，不知道返回类型用int还是bool，这里最后考量发现，这个函数的主题还是求深度，返回的也是深度，只有当异常的时候会直接返回设定值（-1），这样实现了借用求深度的函数，也处理了两个树分叉之间是否平衡的问题

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 dbs(TreeNode* root) {
        if (!root)
            return 0;
 
        int left = dbs(root->left);
        if (left == -1)
            return -1;
        int right = dbs(root->right);
        if (right == -1)
            return -1;
        if (abs(left - right) > 1)
            return -1;
        else
            return max(left, right) + 1;
    }
    bool isBalanced(TreeNode* root) {
        if (dbs(root) == -1)
            return false;
        return true;
    }
};

注意点1：这里要在左右向下递归的过程中设置如果识别到异常（-1），即刻返回上一层，将-1这个信息传递回去。

2.Leetcode257:二叉树的所有路径

题目链接：257. 二叉树的所有路径 - 力扣（LeetCode）

题目解析

个人认为隐式的回溯过程反而更好理解，这里借助的就是值传递出现的隐式回溯过程

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:
    // 值传递的隐式回溯
    vector<string> dfs(TreeNode* root, string path, vector<string>& res) {
        if (!root)
            return res;
 
        path += to_string(root->val);
        if (!root->left && !root->right) {
            res.push_back(path);
            return res;
        }
        dfs(root->left, path + "->", res);
        dfs(root->right, path + "->", res);
        return res;
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        string path;
        return dfs(root, path, res);
    }
};

3.Leetcode404:左叶子之和

题目链接：404. 左叶子之和 - 力扣（LeetCode）

题目解析

不管学什么，总会遇到这种蹩脚的题，为了创新而创新。检查是否为题目中要求的左子叶的条件是，左叶子存在，左叶子的左右叶子不存在。本题采用前序或者后序都可以。

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 dfs(TreeNode* root, int& sum) {
        // 中止条件
        if (!root)
            return;
 
        if (root->left && !root->left->left && !root->left->right)
            sum += root->left->val;
        dfs(root->left, sum);
        dfs(root->right, sum);
        return;
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        dfs(root, sum);
        return sum;
    }
};

注意点1：这里采用了模板式的前序遍历，值得注意的式这里的左右子叶递归的过程不需要先检查root->left或者root->right是否为空，因为中止条件就是root为空，已经隐含检查了，加了没毛病，就是会冗余。

4.Leetcode222:完全二叉树的节点个数

题目链接：222. 完全二叉树的节点个数 - 力扣（LeetCode）

题目解析

需要掌握两种思路，一个是把他当作普通二叉树处理，遇到非空节点就直接计数；另一种是根据完全二叉树的性质，如果搜索部分是满二叉树，返回2^n-1，其中n为层数

，如果不是就计数；这样就退化成了普通二叉树类似的方式处理。

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 dfs(TreeNode* root, int& count) {
        if (!root)
            return;
        dfs(root->left, count);
        dfs(root->right, count);
        count++;
        return;
    }
    int countNodes(TreeNode* root) {
        int count = 0;
        dfs(root, count);
        return count;
    }
};

有返回值且利用性质:


/**
 * 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 depth(TreeNode* root) {
        if (!root)
            return 0;
        int left_depth = 0;
        int right_depth = 0;
 
        // 如果需要向下检索需要再设置一个指针，而不是用原本的root，
        // 和链表的道理一样，但是和递归不一样，递归没有赋值操作
        TreeNode* cur_left = root->left;
        TreeNode* cur_right = root->right;
 
        while (cur_left) {
            cur_left = cur_left->left;
            left_depth++;
        }
        while (cur_right) {
            cur_right = cur_right->right;
            right_depth++;
        }
        if (left_depth == right_depth)
            return (2 << left_depth) - 1;
        int left = depth(root->left);
        int right = depth(root->right);
        return left + right + 1;
    }
    int countNodes(TreeNode* root) { return depth(root); }
};

总结

补打卡第15天，坚持！！！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/973767