算法训练营第十七天||110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和

110.平衡二叉树 

本题实质上是求二叉树的高度差是否超过1，如果超过1则不是平衡二叉树，所以适合用前序遍历递归方法做。

递归：

class Solution {
public:
    int is (TreeNode* root){
        if(root ==nullptr){
            return 0;
        }
        int left = is(root->left);
        if(left == -1){
            return -1;
        }
        int right = is(root->right);
        if(right == -1){
            return -1;
        }
        int result;
        if(abs(left - right) > 1){
            return -1;
        }else{
            result = 1 + max(left,right);
        }
        return result;
    }
    bool isBalanced(TreeNode* root) {
        //递归三部曲
        //1.确定参数和返回值
        //2.确定终止条件
        //3.确定单层递归逻辑
        int res = is(root);
        if(res == -1)return false;
        else return true;
    }
};

257. 二叉树的所有路径

递归：

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一个路径再进入另一个路径。

前序遍历以及回溯的过程如图：

我们先使用递归的方式，来做前序遍历。要知道递归和回溯就是一家的，本题也需要回溯

 

/**
 * 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 bin(TreeNode* root,vector<int>& path,vector<string>& result){
        path.push_back(root->val);//先将根节点插入路径
        if(root==nullptr)return;
        if(root->left==nullptr&&root->right==nullptr){//遇到叶子节点（左右节点都为空）
            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(root->left){
            bin(root->left,path,result);
            path.pop_back();
        }
        if(root->right){
            bin(root->right,path,result);
            path.pop_back();
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;
        bin(root,path,result);
        return result;

    }
};

404.左叶子之和 

首先要注意是判断左叶子，不是二叉树左侧节点，所以不要上来想着层序遍历。

因为题目中其实没有说清楚左叶子究竟是什么节点，那么我来给出左叶子的明确定义：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点

大家思考一下如下图中二叉树，左叶子之和究竟是多少？

 其实是0，因为这棵树根本没有左叶子！

但看这个图的左叶子之和是多少？

相信通过这两个图，大家对最左叶子的定义有明确理解了。

那么判断当前节点是不是左叶子是无法判断的，必须要通过节点的父节点来判断其左孩子是不是左叶子。

如果该节点的左节点不为空，该节点的左节点的左节点为空，该节点的左节点的右节点为空，则找到了一个左叶子，判断代码如下：

if (node->left != NULL && node->left->left == NULL && node->left->right == NULL) {
    左叶子节点处理逻辑
}

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

递归三部曲：

1. 确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int

使用题目中给出的函数就可以了。

1. 确定终止条件

如果遍历到空节点，那么左叶子值一定是0

if (root == NULL) return 0;

1

注意，只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0，那么终止条件为：

if (root == NULL) return 0;
if (root->left == NULL && root->right== NULL) return 0; //其实这个也可以不写，如果不写不影响结果，但就会让递归多进行了一层。

1
2

1. 确定单层递归的逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

代码如下：

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;

整体代码：

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root == nullptr) return 0;
        if(root->left == nullptr&&root->right == nullptr) return 0;
        int sum1 = sumOfLeftLeaves(root->left);//左
        if(root->left!=nullptr&&root->left->left==nullptr&&root->left->right==nullptr){//找到了左叶子节点
            sum1 = root->left->val;
        }
        int sum2 = sumOfLeftLeaves(root->right);//右
        int sum =sum1+sum2;
        return sum;


    }
};

总结：今天的题感觉很不好做，递归总是想不到，还是需要多练习。