【C++编程能力提升】

一、110 平衡二叉树

题目链接：110 平衡二叉树

核心：递归求解左右子树的高度，绝对值大于1则不是平衡二叉树（返回-1）；递归函数的返回值可以设为二叉树的高度：1+max（左、右子树高度）。
注意：递归函数中，调用递归函数获取到左、右子树高度后，需判断是否为-1，因为如果左右子树不是平衡二叉树，就没必要后面再求解二者之差的绝对值了。

    int getHeight(TreeNode* node)
    {//递归法：后序遍历左右中，返回-1表示该树不是平衡二叉树
        if(!node)
            return 0;
        int leftHeight=getHeight(node->left);
        if(leftHeight==-1)
            return -1;  //左子树不是平衡二叉树
        int rightHeight=getHeight(node->right);
        if(rightHeight==-1)
            return -1;  //右子树不是平衡二叉树
        int height=0;
        if(abs(leftHeight-rightHeight)>1)
            return -1;
        height=1+max(leftHeight,rightHeight);   //返回根节点node的二叉树高度
        return height;
    }

    bool isBalanced(TreeNode* root) {
        int height=getHeight(root);
        return height==-1 ? false:true;
    }

二、257 二叉树的所有路径

题目链接：257 二叉树的所有路径

核心：递归法+回溯法，一次递归调用后紧跟一次回溯
（1）求解路径是从根节点出发直到叶子节点，因此采用前序遍历（中左右）；
（2）终止条件：当前节点是叶子节点，即左右孩子都为空，需要将此前遍历的所有节点元素都转换为string类型，并记录到路径的数组中，表示一条路径遍历结束；
（3）递归左右子树时，需要先判断节点是否为空，空节点不存在路径，因此记录空节点无意义；递归之后，紧跟着一次回溯，即pop，回到路径的上一个节点。
注意：对回溯的理解不够深入；以及对终止条件进行处理时得到一条路径后直接return的实现也存在疑问。

    //递归法+回溯法，一次递归后面必须跟着一次回溯！
    void getPath(TreeNode* cur, vector<int>& path,vector<string>& result)
    {//前序遍历：中左右，即先处理中间结点
        path.push_back(cur->val);   //中
        if(!cur->left && !cur->right)
        {//终止条件：处理叶子节点，此时说明该条路径结束，需回溯到上一个节点寻找其他路径
            string sPath;   //将int类型的path转化为string类型，并push到result
            for(int i=0;i<path.size()-1;++i)
            {//path转换为string时中间需插入->，因此先处理前n-1个元素，最后一个元素单独插入
                sPath+=to_string(path[i]);
                sPath+="->";
            }
            sPath+=to_string(path[path.size()-1]); //插入最后一个节点
            result.push_back(sPath);
            return;     //注意得到该条path后需return,因为此时已处理结束
//对这里的return不太理解，比如遍历到5时是第一个叶子节点，这时return之后如何遍历其他路径？
        }
        if(cur->left)   //左
        {//只有在节点不为空时才递归遍历
            getPath(cur->left,path,result);
            path.pop_back(); //回溯至上一个
        }
        if(cur->right)  //右
        {
            getPath(cur->right,path,result);
            path.pop_back(); //回溯至上一个
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
    //递归法：
        vector<string> result;
        vector<int> path;
        getPath(root,path,result);
        return result;
    }

三、404 左叶子之和

题目链接：404 左叶子之和

核心：明确左叶子的判定需满足三个条件，即某父节点的左孩子不为空，且父节点的左孩子的左右孩子都为空，此时该父节点的左孩子为左叶子。
（1）迭代法：类似前序遍历的迭代法，借助于栈，终止条件是root为空则返回0，否则root不为空时将root入栈；对【中】的处理是：弹出当前栈顶元素判断是否为左叶子节点，若是则累加左叶子节点值，否则将当前栈顶元素的左右孩子（非空）入栈，循环遍历直至栈为空，表示已遍历全部节点。
（2）递归法：采用后序遍历（左右中），其中的逻辑理解不够深入，主要是递归左子树之后判断左叶子节点的操作。

   int sumOfLeftLeaves(TreeNode* root) {
    //递归法：后序遍历
    if(!root)
        return 0;
    int leftsum=sumOfLeftLeaves(root->left);    //左
    if(root->left && !root->left->left && !root->left->right)
        leftsum=root->left->val;    //此句与递归左得到leftsum的关系不理解？
    int rightsum=sumOfLeftLeaves(root->right);  //右
    int res=leftsum+rightsum;   //中，左子树的左叶子+右子树的左叶子
    return res;
    /*
    //迭代法：借助栈使用前序遍历：中左右
    int res=0;  //记录左叶子之和
    stack<TreeNode*> stk;
    if(!root)
        return 0;
    stk.push(root);
    while(!stk.empty())
    {
        TreeNode* node=stk.top();   //处理【中】
        stk.pop();
        if(node->left && !node->left->left && !node->left->right)
            res+=node->left->val;   //左叶子
        if(node->left)
            stk.push(node->left);   //左
        if(node->right)
            stk.push(node->right);  //右
    }
    return res;
    */
    }