二刷代码随想录算法训练营第十七天 |110.平衡二叉树、257. 二叉树的所有路径 、404.左叶子之和

目录

一、110. 平衡二叉树

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

三、404. 左叶子之和

---

一、110. 平衡二叉树

题目链接：力扣

文章讲解：代码随想录

视频讲解： 后序遍历求高度，高度判断是否平衡 | LeetCode：110.平衡二叉树

题目：

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

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

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

代码：

/**
 * 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 compare(TreeNode* root){
        if(!root) return 0;
        int left_value = compare(root->left);
        if(left_value == -1) return -1;
        int right_value = compare(root->right);
        if(right_value == -1) return -1;

        return abs(left_value - right_value) > 1 ? -1 : 1+max(left_value, right_value); 
    }
    bool isBalanced(TreeNode* root) {
        return  compare(root) != -1;
    }

};

时间复杂度: O(n)                                        空间复杂度: O(n)

⏲：1:37

总结：

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。从上到下，前序遍历（中左右）
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。从下到上，后序遍历（左右中）

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

题目链接：力扣

文章讲解：代码随想录

视频讲解：递归中带着回溯，你感受到了没？| LeetCode：257. 二叉树的所有路径

题目：

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

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

代码：

/**
 * 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 order(vector<string> &ans, TreeNode *node, string road)
    {
        road += to_string(node->val);
        if (!node->left && !node->right)
        {
            ans.push_back(road);
            return;
        }
        if (node->left) order(ans, node->left, road + "->");
        if (node->right) order(ans, node->right, road + "->");
    }*/
    vector<string> binaryTreePaths(TreeNode* root) {
        //vector<string> ans;
        //order(ans, root, "");
        //return ans;
        //迭代
        vector<string> ans;
        stack<TreeNode*> st;
        stack<string> road;
        if (!root) return ans;
        st.push(root);
        road.push(to_string(root->val));
        while (!st.empty())
        {
            TreeNode *node = st.top();
            st.pop();
            string path = road.top();
            road.pop();
            if (!node->left && !node->right)
                ans.push_back(path);
            if (node->left)
            {
                st.push(node->left);
                road.push(path + "->" + to_string(node->left->val));
            }
            if (node->right)
            {
                st.push(node->right);
                road.push(path + "->" + to_string(node->right->val));
            }
            
        }
        return ans;
    }
};

时间复杂度: O(n^2)                                        空间复杂度: O(n^2)

⏲：10:21

总结：1.回溯只要收集最后path即可。2.迭代法用两个栈，一个用来处理road的回溯。

三、404. 左叶子之和

题目链接：力扣

文章讲解：代码随想录

视频讲解：二叉树的题目中，总有一些规则让你找不到北 | LeetCode：404.左叶子之和

题目：

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

代码：

/**
 * 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 order(TreeNode *node)
    {
        if (!node || (!node->left && !node->right)) return 0;
        int leftvalue = 0;
        if (node->left != NULL && !node->left->left && !node->left->right)
            leftvalue = node->left->val;
        return order(node->left) +  order(node->right) + leftvalue; 
    }*/
    int sumOfLeftLeaves(TreeNode* root) {
        //return order(root);
        stack<TreeNode*> stack;
        if (!root) return 0;
        stack.push(root);
        int ans = 0;
        while (!stack.empty())
        {
            TreeNode* node = stack.top();
            stack.pop();
            if (node->left != NULL && !node->left->left && !node->left->right)//左子叶的判断条件
                ans += node->left->val;
            if (node->left) stack.push(node->left);
            if (node->right) stack.push(node->right);
        }
        return ans;
    }
};

时间复杂度: O(n)                                        空间复杂度: O(n)

⏲：4:42

总结：此题关键点在于左子叶的判断条件是根据其父节点判断的。