【代码随想录刷题笔记 Day 18】513.找树左下角的值 | 112. 路径总和 |113.路径总和ii | 106.从中序与后序遍历序列构造二叉树 |

513.找树左下角的值

题目

给定一个二叉树的 根节点 root，请找出该二叉树的 最底层 最左边 节点的值。

假设二叉树中至少有一个节点。

示例

输入: root = [2,1,3]
输出: 1

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
      queue<TreeNode*>que;
        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;
    }
};

112. 路径总和

题目

给你二叉树的根节点 root 和一个表示目标和的整数 targetSum 。判断该树中是否存在 根节点到叶子节点 的路径，这条路径上所有节点值相加等于目标和 targetSum 。如果存在，返回 true ；否则，返回 false 。

示例

 

class Solution {
public:
int res = 0;
vector<int>ref;
void trave(TreeNode* node, vector<int>&path)
{
    path.push_back(node->val);
    if (node->left == NULL && node->right == NULL)
    {
        for(int i = 0; i < path.size(); i++)
        {
            res += path[i];
        }
        ref.push_back(res);
        res = 0;
        return;
    }
    if (node->left)
    {
         trave(node->left, path);
         path.pop_back();
    }
   if (node->right)
   {
       trave(node->right, path);
       path.pop_back();
   }
    
}
    bool hasPathSum(TreeNode* root, int targetSum) {
    vector<int>path;
    if (root == NULL)
    {
        return false;
    }
    trave(root, path);
    for (int i = 0; i < ref.size(); i++)
    {
        if (ref[i] == targetSum)
        {
            return true;
        }
    }
    return false;
    }
};

113.路径总和ii

题目

给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子节点 路径总和等于给定目标和的路径。

示例

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：[[5,4,11,2],[5,8,4,5]]

class Solution {
public:
vector<vector<int>>ref;
void trave(TreeNode* node, vector<int>&path, int count)
{
    path.push_back(node->val);
    if (node->left == NULL && node->right == NULL && count == 0)
    {
        ref.push_back(path);
        return;
    }
    if (node->left == NULL && node->right == NULL)
    {
        return;
    }
    if (node->left)
    {
        count -= node->left->val;
         trave(node->left, path, count);
         path.pop_back();
          count += node->left->val;
    }
   if (node->right)
   {
       count -= node->right->val;
       trave(node->right, path, count);
       path.pop_back();
       count += node->right->val;
   }
    
}
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>>re;
        if (root == NULL)
        {
            return re;
        }
        vector<int>path;
        trave(root,path, targetSum-root->val);
        return ref;
    }
};

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

题目

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

示例

 

class Solution {
public:
    TreeNode* trave(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 index = 0;
        for (; index < inorder.size(); index++)
        {
            if (inorder[index] == rootvalue)
            {
                break;
            }
        }
        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 = trave(leftinorder,leftpostorder);
        root->right = trave(rightinorder,rightpostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0)
        {
            return NULL;
        }
        return trave(inorder, postorder);

    }
};

105.从前序与中序遍历序列构造二叉树

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

 

class Solution {
public:

TreeNode* trave(vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& preorder,int preorderBegin, int preorderEnd)
{
    if (preorderBegin == preorderEnd)
    {
        return NULL;
    }
    int rootvalue = preorder[preorderBegin];
    TreeNode* root = new TreeNode(rootvalue);
    if ((preorderEnd - preorderBegin) == 1)
    {
        return root;
    }
    int index;
    for (index = inorderBegin; index < inorderEnd; index++)
    {
        if (inorder[index] == rootvalue)
        break;
    }
   int leftinorderBegin = inorderBegin;
   int leftinorderEnd = index;

   int rightinorderBegin = index + 1;
   int rightinorderEnd = inorderEnd;

   int leftpreorderBegin = preorderBegin + 1;
   int leftpreorderEnd = preorderBegin + 1 + index - inorderBegin;

   int rightpreorderBegin =  preorderBegin + 1 + index - inorderBegin;
    int rightpreorderEnd = preorderEnd;

    root->left = trave(inorder,leftinorderBegin,leftinorderEnd, preorder,leftpreorderBegin,leftpreorderEnd);
    root->right = trave(inorder,rightinorderBegin,rightinorderEnd, preorder,rightpreorderBegin,rightpreorderEnd);
    return root;
   
}
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size() == 0 || inorder.size() == 0)
        {
            return NULL;
        }
        return trave(inorder, 0, inorder.size(), preorder, 0, preorder.size());

    }
};