DMSXL刷题（11）找树左下角的值 | 路径总和

513. 找树左下角的值

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

        if(node->left)
        {
            depth++;
            traversal(node->left,depth);
            depth--; 
        }

        if(node->right)
        {
            depth++;
            traversal(node->right,depth);
            depth--;
        }
        return ;
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root,0);
        return result;
    }
};

112. 路径总和

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

        if(node->left)
        {
            count-=node->left->val;
            if(travelsal(node->left,count))
                return true;
            count+=node->left->val;
        }

        if(node->right)
        {
            count-=node->right->val;
            if(travelsal(node->right,count)) return true;
            count+=node->right->val;
        }
        return false;

    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        return travelsal(root,targetSum-root->val);
    }
};

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

class Solution {
public:
TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        //如果后续为0就是空
        if(postorder.size() == 0) return NULL;
        //后续数组的最后一个节点就是root节点 左右中
        int rootval=postorder[postorder.size()-1];
        
        TreeNode* root = new TreeNode(rootval);

        if(postorder.size()==1) return root;
        //此root节点在中序数组是切割左右两边的中间点   左中右
        int index = 0;
        for(index=0;index<inorder.size();index++)
        {
            if(inorder[index]==rootval) break;
        }

        //切中序数组  得到中序左子树 与右子树   [0, delimiterIndex) 
        vector<int> leftInorder(inorder.begin(), inorder.begin() + index);
        vector<int> rightInorder(inorder.begin() + index + 1, inorder.end() );

        //切后序数组  得到后序左子树 右子树
        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);


    }
};