代码随想录算法训练营第18天

LeetCode 513. 找树左下角的值

class Solution {
public:
    int depth=0,maxdepth=INT_MIN;
    int result;
    void traversal(TreeNode* root,int& result){
        if(root->left==NULL && root->right==NULL){
            if(depth>maxdepth){
                maxdepth=depth;
                result=root->val;
            }
            return ;
        }
        if(root->left){
            depth++;
            traversal(root->left,result);
            depth--;
        }
        if(root->right){
            depth++;
            traversal(root->right,result);
            depth--;
        }
        return ;
    }
    int findBottomLeftValue(TreeNode* root) {
        traversal(root,result);
        return result;
    }
};

要是想按我这么写，要注意传入的result得是一个引用，这样在步骤中result才会被更改。
如果按卡哥传递值的写法，因为我们最后返回的result并不作为参数传递，所以最后不会被释放，会正常的被更新，而depth在递归函数中会被正常更新，在最后会被释放，但是它不必被返回，所以不用管它。
也可以只传递root节点，不传递result和depth。

LeetCode 112. 路径总和

class Solution {
public:
    bool traversal(TreeNode* root,int count){
        if(!root->left && !root->right && count==0)return true;
        if(!root->left && !root->right && count!=0)return false;

        if(root->left){
            if(traversal(root->left,count-(root->left->val)))return true;
        }
        if(root->right){
            if(traversal(root->right,count-(root->right->val)))return true;
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(!root)return false;
        return traversal(root,targetSum-root->val);
    }
};

LeetCode 106. 从中序与后序遍历序列构造二叉树

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size()==0)return NULL;
        int rootvalue=postorder[postorder.size()-1];
        TreeNode* root=new TreeNode(rootvalue);
        if(postorder.size()==1)return root;

        int delimiterIndex;
        for(delimiterIndex=0;delimiterIndex<inorder.size();delimiterIndex++){
            if(inorder[delimiterIndex]==rootvalue)break;
        }

        //切割中序遍历数组
        vector<int> leftinorder(inorder.begin(),inorder.begin()+delimiterIndex);
        vector<int> rightinorder(inorder.begin()+delimiterIndex+1,inorder.end());
        //舍弃postorder的末尾元素，方便进行下一步
        postorder.resize(postorder.size()-1);
        //切割后序遍历数组
        vector<int> leftpostorder(postorder.begin(),postorder.begin()+leftinorder.size());
        vector<int> rightpostorder(postorder.begin()+leftinorder.size(),postorder.end());

        root->left=traversal(leftinorder,leftpostorder);
        root->right=traversal(rightinorder,rightpostorder);

        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0 || postorder.size()==0)return NULL;
        return traversal(inorder,postorder);
    }
};

切割数组过程比较复杂，最后对左右子树分别进行递归传入的分别是以中序和后序遍历的左右子数组。