【代码随想录】day17

最新推荐文章于 2024-07-24 22:13:06 发布

weixin_47041555

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量415

点赞数 8

文章标签：算法

本文链接：https://blog.csdn.net/weixin_47041555/article/details/136706400

版权

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

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

一、110平衡二叉树

递归判断高度差是否<=1

class Solution {
public:
    int getHeight(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        int leftHeight = getHeight(node->left);
        int rightHeight = getHeight(node->right);
        return 1 + max(leftHeight, rightHeight);       
    }

    bool subBalanced(TreeNode* node) {
        if (node == nullptr) return true;
        int left = getHeight(node->left);
        int right = getHeight(node->right);
        if (left > right + 1 || left < right - 1) {
            return false;
        }
        return subBalanced(node->left) && subBalanced(node->right);

    }
    bool isBalanced(TreeNode* root) {
        return subBalanced(root);
    }
};

优化版：

class Solution {
public:
    int getHeight(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        int leftHeight = getHeight(node->left);
        if (leftHeight == -1) {
            return -1;
        }
        int rightHeight = getHeight(node->right);
        if (rightHeight == -1) {
            return -1;
        }
        if (abs(leftHeight - rightHeight) > 1) {
            return -1;
        }
        return 1 + max(leftHeight, rightHeight);       
    }


    bool isBalanced(TreeNode* root) {
        int result = getHeight(root);
        return result != -1;
    }
};

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

class Solution {
public:
    vector<string> res; 
    void dfs(vector<string>& res, vector<int>& path, TreeNode* node) {
        path.push_back(node->val);
        if (node->left == nullptr && node->right == nullptr) {
            string s;
            for (int i = 0; i < path.size(); i ++) {
                s += to_string(path[i]);
                if (i != path.size() - 1) {
                    s += "->";
                }
            }
            res.push_back(s);
        }
        if (node->left) {
            dfs(res, path, node->left);
            path.pop_back();
        }
        if (node->right) {
            dfs(res, path, node->right);
            path.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        vector<int> path;
        dfs(res, path, root);
        return res;
    }
};

精简版：

class Solution {
public:
    vector<string> res; 
    void dfs(vector<string>& res, string path, TreeNode* node) {
        path += to_string(node->val);
        if (node->left == nullptr && node->right == nullptr) {
            res.push_back(path);
            return;
        }
        if (node->left) {
            dfs(res, path + "->", node->left);
        }
        if (node->right) {
            dfs(res, path + "->", node->right);
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> res;
        string path;
        dfs(res, path, root);
        return res;
    }
};

三、404左叶子之和

class Solution {
public:
    int getLeft(TreeNode* node) {
        if (node == nullptr) {
            return 0;
        }
        int left = getLeft(node->left);
        int right = getLeft(node->right);
        if (node->left && node->left->left == nullptr && node->left->right==nullptr) {
            left += node->left->val;
        }
        return left + right;
    }
    int sumOfLeftLeaves(TreeNode* root) {
        return getLeft(root);
    }
};