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

110.平衡二叉树

思路：判断二叉树是否平衡，主要判断二叉树左右节点的高度差是否大于1，如果大于1就不平衡。需要判断左右节点高度，因此是后序遍历。利用递归遍历，先判断递归函数的参数和返回类型，然后判断终止条件，当节点为空时，返回0（此时高度为0），然后写单侧递归的逻辑，如果左右节点的高度差大于-1，则返回-1，如果左右节点的高度有-1，则返回-1，如果，左右节点的高度差<1,返回左右节点的最大高度+1。

class Solution {
public:
    int getHeight(TreeNode* root)
    {
        if(root==NULL)
        {
            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 height = getHeight(root);
        if(height==-1)
        {
            return false;
        }
        else
        {
            return true; 
        }
    }
};

257.二叉树的所有路径

思路：要搜寻二叉树的所有路径，将路径保存到path中，每记录完一整条路径，就将path输入到result中，并且回溯path，记录新的路径。定义的path内部为int类型，要注意int向string类型的转换。

class Solution {
public:
    void traversal(TreeNode* root,vector<int>&path,vector<string>&result)
    {
        path.push_back(root->val);
        if(root->left==NULL&&root->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(root->left)
        {
            traversal(root->left,path,result);
            path.pop_back();//回溯
        }
        if(root->right)
        {
            traversal(root->right,path,result);
            path.pop_back();
        }
        return;
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<int> path;
        vector<string> result;
        if(root==NULL)
        {
            return result;
        }
        traversal(root,path,result);
        return result;
    }
};

404.左叶子之和

思路：要判断节点是否为叶子节点，且叶子节点是否为父节点的左叶子节点。利用递归遍历，先判断递归函数的参数和返回类型，然后确定递归函数的终止条件，当节点为空时，返回0，此时当前节点的左叶子数为0，当节点为叶子节点时，返回0，此时当前节点的左叶子数为0。确定单层递归的逻辑，左：获取左节点的左叶子和，如果左子节点为叶子节点，当前节点处的左叶子和为左子节点的值。右：获取右节点的左叶子和。中：将左右节点的左叶子和求和。

class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==NULL)
        {
            return 0;
        }
        if(root->left==NULL&&root->right==NULL)
        {
            return 0;
        }
        //后序遍历
        int leftnum = sumOfLeftLeaves(root->left);
        int rightnum = sumOfLeftLeaves(root->right);
        if(root->left!=NULL&&root->left->left==NULL&&root->left->right==NULL)
        {
            leftnum = root->left->val;
        }
        int result = leftnum+rightnum;
        return result;
    }
};

收获：

要注意递归函数的逻辑、终止条件。

通过第二题理解回溯的意义，在遍历每一条路径中回溯的作用。