代码随想录day18｜找到左下角的值、路径总和、从中序与后序遍历序列构造二叉树

找到左下角的值

这道题是找到最底层的最左边的值，很明显用层序遍历会简单很多，因为层序遍历的最后一行的第一个值就是我们要找到的结果。如代码所示，用result来记录结果，result在每一层都记录一次第一个数的值，遍历完result就是最后一层第一个数的值，也就找到了答案。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == NULL) return 0;
        que.push(root);
        int result = 0;
        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0;i < size;i++)
            {
                TreeNode* node = que.front();
                que.pop();
                if(i == 0) result = node->val;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return result;
    }
};

路径总和

这道题使用深度遍历的方法来执行，找寻二叉树的路径，需要回溯。

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

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

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

从中序和后序遍历序列构造二叉树，主要是掌握基本的思路。首先我们肯定是得到后序遍历的最后一个节点作为根节点，然后在中序序列中找到这个节点作为我们的切割点，我们先将中序序列切割成左区间和右区间，然后我们根据左区间的长度切割出后序序列的左区间，并根据中序序列的长度切割出后序序列的右区间。然后不断递归遍历，这样我们就构造出了二叉树。并且值得注意的是，我们需要new一个root节点来返回的我们的二叉树。 

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder,vector<int>& postorder){
        
        if(postorder.size() == NULL && postorder.size() == NULL) return NULL;

        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);
        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.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) {
        return traversal(inorder,postorder);
    }
};