代码随想录算法训练营第十五天|LeetCode110.平衡二叉树、LeetCode257. 二叉树的所有路径、LeetCode404.左叶子之和、LeetCode222.完全二叉树的节点个数-优快云博客

/**
 * 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* root)
    {
        if(root == nullptr) return 0;
        int leftHeight = getHeight(root->left);
        if(leftHeight == -1)
            return -1;
        int rightHeight = getHeight(root->right);
        if(rightHeight == -1)
            return -1;
        
        if(abs(leftHeight - rightHeight) > 1)
            return -1;
        else
            return 1 + max(leftHeight, rightHeight);
        
    }

    bool isBalanced(TreeNode* root) {
        int ret = getHeight(root);
        if(ret == -1)
            return false;
        else
            return true;
    }
};

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

题目链接：

257. 二叉树的所有路径 - 力扣（LeetCode）

题目思路：

先序递归遍历：

由于我们要找的路径都是从根节点开始，所以采用先序遍历（中左右）。通过不断的遍历结点并回溯，直到遍历完所有结点，并且当遍历到叶子结点时，将路径保存。

代码：

/**
 * 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 traverse(TreeNode* root, vector<int>& path, vector<string>& result)
    {
        path.push_back(root->val);
        if(root->left == nullptr && root->right == nullptr)
        {
            string ret = to_string(path[0]);
            for(int i = 1; i < path.size(); i++)
            {
                ret += "->";
                ret += to_string(path[i]);
            }
            result.push_back(ret);
        }
        if(root->left)
        {
            traverse(root->left, path, result);
            path.pop_back();
        }
        if(root->right)
        {
            traverse(root->right, path, result);
            path.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;
        traverse(root, path, result);
        return result;
    }
};

三、LeetCode404.左叶子之和

题目链接：

404. 左叶子之和 - 力扣（LeetCode）

题目思路：

可以通过前序或者后序递归遍历，前序遍历要设置一个公共的sum来保存所有左叶子结点的值的和。通过判断当前结点的左节点非空，且当前结点的左孩子结点的左右孩子结点都为空来判断当前结点的左孩子结点是否为叶子结点。

如果通过后序遍历，则需要将左叶子结点的值进行返回。

代码：

先序遍历：

/**
 * 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 preOrderSum(TreeNode* root, int& sum)
    {
        if(root == nullptr) return;

        if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr)
        {
            sum += root->left->val;
        }
        preOrderSum(root->left, sum);
        preOrderSum(root->right, sum);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        int sum = 0;
        preOrderSum(root, sum);
        return sum;
    }
};

后序遍历：

/**
 * 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 sumOfLeftLeaves(TreeNode* root) {
        if(root == nullptr)
            return 0;
        if(root->left == nullptr && root->right == nullptr)
            return 0;
        
        int leftNum = sumOfLeftLeaves(root->left);
        if(root->left != nullptr && root->left->left == nullptr && root->left->right == nullptr)
        {
            leftNum = root->left->val;
        }
        int rightNum = sumOfLeftLeaves(root->right);

        return leftNum + rightNum;

    }
};

四、LeetCode222.完全二叉树的节点个数

题目链接：

222. 完全二叉树的节点个数 - 力扣（LeetCode）

题目思路：

直接通过任何遍历结点的方式进行计数并返回即可，通过后序遍历或者层序遍历都可以。

代码：

后序遍历：

/**
 * 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 {
private:
    int getNodeNum(TreeNode* root)
    {
        if(root == nullptr) return 0;
        int leftNum = getNodeNum(root->left);
        int rightNum = getNodeNum(root->right);
        return leftNum + rightNum + 1; // 左节点 + 右结点 + 当前结点
    }
public:
    int countNodes(TreeNode* root) {
        return getNodeNum(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 countNodes(TreeNode* root) {
        if(root == nullptr) return 0;

        queue<TreeNode*> que;
        que.push(root);
        int nodeNum = 0;
        while(!que.empty())
        {
            TreeNode* pCur = que.front();
            que.pop();
            nodeNum++;
            if(pCur->left)
            {
                que.push(pCur->left);
            }
            if(pCur->right)
            {
                que.push(pCur->right);
            }
        }
        return nodeNum;
    }
};