Day18 | 513. 找树左下角的值、112.路径总和、106.从中序与后序遍历序列构造二叉树

513.找树左下角的值

用层序遍历，找最后一层最左边的值（也就是每次入队的第一个元素），就可以找到树左下角的值

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int res=0;
        while (!q.empty()){
            int size=q.size();

            for (int i = 0; i < size; ++i) {
                TreeNode*p=q.front();
                q.pop();
                if(p->left)q.push(p->left);
                if(p->right)q.push(p->right);
                if(i==0)res=p->val;
            }

        }
        return res;
    }
};

112.路径总和

与257.二叉树的所有路径思路相同，用后序遍历把左右孩子的情况返回给根节点，每次递归完后（把个结点的值加入这条路径中）需要回溯（再把这个结点的值从路径中减去，返回上一个结点）

class Solution {
public:
    void findPath(TreeNode*node,int &sum,vector<int>& res){
        sum+=node->val;//终止条件写在这，保证叶子结点的值也已加入路径中
        if(node->left==nullptr&&node->right== nullptr) {//叶子
            res.push_back(sum);
            return;
        }
        if(node->left){
            findPath(node->left,sum,res);
            sum-=node->left->val;
        }
        if(node->right){
            findPath(node->right,sum,res);
            sum-=node->right->val;
        }
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root== nullptr)return 0;
        int sum=0;
        vector<int> res;//记录所有路径的数值和
        findPath(root,sum,res);
        for (int i = 0; i < res.size(); ++i) {
            if(res[i]==targetSum)return 1;
        }
        return 0;
    }
};

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

重构二叉树需要先找到根结点，再找左右子树，后序遍历的根节点是最后一个值，再从中序遍历里找到根结点对应的值来切分左子树和右子树

上图为先序和中序，后序和中序同理

class Solution {
public:
    int find(vector<int>& inorder,int val){
    //find函数用来找中序序列里根结点的位置
        for (int i = 0; i < inorder.size(); ++i) {
            if(inorder[i]==val)return i;
        }
        return -1;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int n=inorder.size();
        if(n<=0)return nullptr;
        TreeNode*root=new TreeNode();
        root->val=postorder[n-1];
        int k= find(inorder,root->val);
        vector<int> leftInorder(inorder.begin(),inorder.begin()+k);
        vector<int> leftPostOrder(postorder.begin(),postorder.begin()+k);
        root->left= buildTree(leftInorder,leftPostOrder);
        vector<int> rightInorder(inorder.begin()+k+1,inorder.end());
        vector<int> rightPostOrder(postorder.begin()+k,postorder.begin()+n-1);
        root->right= buildTree(rightInorder,rightPostOrder);
        return root;
    }
};