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

110.平衡二叉树

平衡二叉树：一个二叉树每个节点的左右子树的高度差的绝对值不超过1
深度：从根节点到该节点的最长简单路径边的条数（从上到下查，使用前序）
高度：从该节点到叶子节点的最长简单路径边的条数（从下到上查，使用后序）

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

参数：当前传入节点
返回值：以当前传入节点为根节点的树的高度

2. 明确终止条件

遇到空节点终止，返回0，表示当前节点为根节点的树的高度为0

3. 单层递归需要处理的（不太理解）
   分别求出左右子树的高度，如果差值小于等于1，就返回当前二叉树的高度，否则返回-1，表示不是二叉平衡树

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;

        //分别求出左右子树的高度 如果差值小于1则返回当前二叉树的高度
        //否则就返回-1，表示已经不是二叉平衡树
        if(abs(leftheight-rightheight)>1){
            return -1;
        }else {
            return 1+max(leftheight,rightheight);
        }
    }
    bool isBalanced(TreeNode* root) {

        return getheight(root)==-1? false:true;
    }
};

257. 二叉树的所有路径

1.递归函数参数以及返回值的确定
传入根节点，记录每一条路径的path，存放最后结果的result，这里的递归不需要返回值

void traversal(TreeNode* node,vector<int> &path,vector<string> &result)

2.确定终止条件
到叶子节点就可以结束了，不需要遍历到NULL

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

3.确定单层递归逻辑
使用前序遍历，需要先处理中间节点，先放进path
然后再进行递归、回溯操作

class Solution {
public:
    void traversal(TreeNode* node,vector<int> &path,vector<string> &result){
        //为什么在这里写 使用前序遍历 需要将最后叶子节点也加入到path中
        path.push_back(node->val);
        //这里才到了叶子节点
        //这里不需要判断到NULL  只需要到叶子节点就好
        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;
    }
};

404.左叶子之和

首先要明白这里的左叶子节点是什么
节点A的左孩子不为空，但是左孩子的左右孩子都为空（说明是叶子节点），A节点的左孩子就是左叶子节点

使用后序遍历，因为需要通过递归函数的返回值累加求取左叶子节点的数值之和

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

需要判断是否是树的左叶子节点，所以一定要传入树的根节点，返回的是数值之和

2. 确定终止条件

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

if(root==NULL)return 0;
        //排除叶子节点的可能 叶子节点不是左叶子
        if(root->left==NULL && root->right==NULL)return 0;

3. 确定单层递归的逻辑

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

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
         if(root==NULL)return 0;
        //排除叶子节点的可能 叶子节点不是左叶子
        if(root->left==NULL && root->right==NULL)return 0;

        int leftval=sumOfLeftLeaves(root->left);    //左
        //判断左叶子节点 左孩子的左右孩子不为空 根节点的左孩子才是左叶子
        if(root->left && !root->left->left && !root->left->right){
            leftval=root->left->val;
        }
        int rightval=sumOfLeftLeaves(root->right);  //右

        int sum=leftval+rightval;   //中
        return sum;
    }
};