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

第六章二叉树part04（二刷迭代法）

110. 平衡二叉树

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

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

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

个人思路：递归求高度，前序遍历判断每一个节点

class Solution {
public:
    //  递归获取节点高度
    int getHeight(TreeNode* node){
        if(node==nullptr)  return 0;
        return max(getHeight(node->left),getHeight(node->right))+1;
    }
    bool isBalanced(TreeNode* root) {
        //终止条件
        if(root==nullptr)  return true;
        if(getHeight(root->left)-getHeight(root->right)<-1||getHeight(root->left)-getHeight(root->right)>1)  return false;
        //递归过程
        return isBalanced(root->left)&&isBalanced(root->right);
    }
};

 可以ac但是细节上有点问题，使用前序遍历从高度做判断是不准确的，它的子节点可能不平衡，会在后面才判断出来，所以结果上没有问题。

涉及高度应该使用后序遍历，涉及深度使用前序遍历。

以下代码参考后写出

class Solution {
public:
    //使用后序遍历获得节点高度，其中不平衡节点高度记为-1
    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;

        return abs(leftHeight-rightHeight)>1?-1:1+max(leftHeight,rightHeight);  //中
    }
    bool isBalanced(TreeNode* root) {
        return getHeight(root)==-1?false:true;
    }
};

二刷掌握迭代法

257. 二叉树的所有路径

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

叶子节点 是指没有子节点的节点。

示例 1：

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

一刷没写出来。

使用递归+回溯 

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

注意在函数定义的时候void traversal(TreeNode* cur, string path, vector<string>& result) ，定义的是string path，每次都是复制赋值，不用使用引用，否则就无法做到回溯的效果。（这里涉及到C++语法知识）

那么在如上代码中，貌似没有看到回溯的逻辑，其实不然，回溯就隐藏在traversal(cur->left, path + "->", result);中的 path + "->"。 每次函数调用完，path依然是没有加上"->" 的，这就是回溯了。

404. 左叶子之和

给定二叉树的根节点 root ，返回所有左叶子之和。

使用递归前序遍历，通过判断节点是否为叶子节点以及节点是父节点的左节点来加入左叶子。

class Solution {
public:
    int result=0;
    void traversal(TreeNode* node){
        if(node==NULL)  return;
        if(node->left!=NULL&&node->left->left==NULL&&node->left->right==NULL)  result+=node->left->val;
        if(node->left)  traversal(node->left);
        if(node->right)  traversal(node->right);
    }
    int sumOfLeftLeaves(TreeNode* root) {
        traversal(root);
        return result;
    }
};

另一种写法 

 int sumOfLeftLeaves(TreeNode* root) {
        if(root==NULL)  return 0;
        int leftVal=0;
        if(root->left&&!root->left->left&&!root->left->right){
            leftVal=root->left->val;
        }
        return leftVal+sumOfLeftLeaves(root->left)+sumOfLeftLeaves(root->right);
    }

以上三题二刷可尝试迭代法