代码随想录 | Day17

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

---

今日学习目标

平衡二叉树（110）
二叉树的所有路径（257）
左叶子之和（404）

一、算法题

1.

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

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

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

示例 1：

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

思路：二叉树的高度遍历为后序遍历，递归的单层逻辑则是判断左右子树的高度差。

代码：

/**
 * 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* 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;
        int result;
        if(abs(leftHeight - rightHeight) > 1) result = -1;
        else result = 1 + max(leftHeight, rightHeight);
        return result;
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root) == -1 ? false : true;
    }
};

2.二叉树的所有路径

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

输入：root = [1,2,3,null,5]
输出：[“1->2->5”,“1->3”]

思路：显而易见，这道题用递归算法，首先确定递归函数的返回值和参数，参数中使用vector记录节点和路径，所以递归函数无返回值，由于返回从根节点到叶子节点的路径，采用前序遍历。然后确定终止条件，遍历到叶子节点时，要返回的是路径，单纯的节点为空会比较复杂，所以采用以下终止条件。

if(node->left == NULL && node-<right == NULL)

由于要返回的是根节点到叶子节点的路径，在遍历完当前路径后，要将该节点弹出。

代码：

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

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

3.左叶子之和

题目：
给定二叉树的根节点 root ，返回所有左叶子之和。
示例 1：

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

思路：首先明确题目，左叶子而不是左侧叶子节点，本题的关键在于判断节点是否为左叶子节点，通过父节点判断子节点是否为左叶子节点如下：

 if(root->left && !root->left->left && !root->left->right)

代码：

/**
 * 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 == NULL) return 0;
        if(root->left == NULL && root->right == NULL) 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;

    }
};

---

今日心得

对于递归的终止条件判断的不准确，初步涉及到了回溯，也不是那么难以理解。

学习及参考书籍

代码随想录