代码随想录算法训练营第十八天 | 513.找树左下角的值，112. 路径总和，113.路径总和ii，106.从中序与后序遍历序列构造二叉树，105.从前序与中序遍历序列构造二叉树-CSDN博客

本文链接：https://blog.csdn.net/qq_43795579/article/details/136591267

文章介绍了如何使用前序、中序和后序遍历来构建二叉树，包括findBottomLeftValue方法找到最底层左叶节点的值，hasPathSum检查是否存在路径和为目标和的路径，以及pathSum和buildTree方法利用这些遍历来构造完整的二叉树结构。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        int res = 0;
        queue<TreeNode*> q;
        
        if(root == NULL){
            return res;
        }
        
        q.push(root);
        while(!q.empty()){
            int size = q.size();
            vector<int> resVec;
            while(size--){
                TreeNode * node = q.front();
                q.pop();
                resVec.push_back(node->val);
                if(node->left){
                    q.push(node->left);
                }
                if(node->right){
                    q.push(node->right);
                }
            }
            if(q.empty()){
                res = resVec[0];
            }
        }
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool res = false;
    void traceback(TreeNode * node,int sum,int & target){
        if(node == NULL){
            return;
        }
        if(node->left == NULL && node->right == NULL){
            sum += node->val;
            if(sum == target){
                res = true;
            }
            return;
        }
        
        sum+= node->val;
        traceback(node->left,sum,target);
        traceback(node->right,sum,target);
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        traceback(root,0,targetSum);
        return res;
    }
};

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> res;
    void traceback(TreeNode* node, int curSum, int &targetSum,vector<int> path){
        if(node== NULL){
            return;
        }
        if(node->left == NULL && node->right == NULL){
            path.push_back(node->val);
            curSum+=node->val;
            if( curSum == targetSum){
                res.push_back(path);
            }
            return;
        }
        path.push_back(node->val);
        traceback(node->left,curSum+node->val,targetSum,path);
        traceback(node->right,curSum+node->val,targetSum,path);
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> path;
        traceback(root,0,targetSum,path);
        return res;
    }
};

在这里插入图片描述

在这里插入代码片/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* traceback(vector<int> preorder,vector<int> inorder){
        if(preorder.size() == 0){
           return NULL;
        }
        int rootVal = preorder[0];
        TreeNode * root = new TreeNode(rootVal);
        if(preorder.size() == 1){
           return root;
        }

        int index = 0;
        for(int i = 0;i< inorder.size();i++){
           if(root->val == inorder[i]){
               index = i;
               break;
           }
        }

        vector<int> leftInorder(inorder.begin(),inorder.begin()+index);
        vector<int> rightInorder(inorder.begin()+index+1,inorder.end());

        reverse(preorder.begin(),preorder.end());
        preorder.resize(preorder.size()-1);
        reverse(preorder.begin(),preorder.end());

        vector<int> leftPreorder(preorder.begin(),preorder.begin()+leftInorder.size());
        vector<int> rightPreorder(preorder.begin()+leftInorder.size(),preorder.end());

        root->left = traceback(leftPreorder,leftInorder);
        root->right = traceback(rightPreorder,rightInorder);

        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
              return traceback(preorder,inorder);

    }
};

在这里插入图片描述

/**
 1. Definition for a binary tree node.
 2. struct TreeNode {
 3.     int val;
 4.     TreeNode *left;
 5.     TreeNode *right;
 6.     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 7.     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 8.     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 9. };
 */
class Solution {
public:
    TreeNode * traceback(vector<int> inorder, vector<int> postorder){
            if(postorder.size() == 0){
               return NULL;
            }
            int rootVal = postorder[postorder.size()-1];
            TreeNode * node = new TreeNode(rootVal);

            if(postorder.size() == 1){
               return node;
            }
            
            int indexMid = 0;
            for(int i = 0;i< inorder.size();i++){
                if(inorder[i] == node->val){
                    indexMid = i;
                    break;
                }
            }
            vector<int> leftInorder(inorder.begin(),inorder.begin()+indexMid);
            vector<int> rightInorder(inorder.begin()+ indexMid + 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());

            node->left = traceback(leftInorder,leftPostorder);
            node->right = traceback(rightInorder,rightPostorder);

            return node;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
            return traceback(inorder,postorder);
    }
};