day 18 ||中序、后序构造二叉树

513.找树左下角的值

题目

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

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

题解

迭代法，利用层序遍历,在遍历每一层时，记录最左节点的值

/**
 * 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) {
       queue<TreeNode*> que;
       int result = 0;
       que.push(root);
       while(!que.empty()){
           int size = que.size();
           for(int i = 0; i < size; i++){
               TreeNode* node =  que.front();
               if(i == 0) result = node -> val ;  //不断更新每层最左节点的值，最后result的值就是最底层最左边节点的值
               que.pop();
               if(node -> left) que.push(node->left);
               if(node ->right ) que.push(node->right);
           }
       }
   
    return result;

    }
};

112.路径总和

题目

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

叶子节点 是指没有子节点的节点。

示例 1：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22
输出：true
解释：等于目标和的根节点到叶节点路径如上图所示。

题解

/**
 * 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 traversal(TreeNode* node,int count){
          if(node -> left == NULL && node -> right == NULL && count == 0) return true;
          if(node -> left == nullptr && node -> right == nullptr) 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 == nullptr) return false;    //一定要添加这段逻辑；
      bool result = traversal(root,targetSum - root->val); //这里要减去root节点的值
      return result;
             
    }
};

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

题目

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

示例 1:

输入：inorder = [9,3,15,20,7], postorder = [9,15,7,20,3]
输出：[3,9,20,null,null,15,7]
示例 2:

输入：inorder = [-1], postorder = [-1]
输出：[-1]

题解

------逻辑

1. 后序数组size为0，为空节点，构造完成
2. 后序数组的最后一个元素为节点元素【把他构造为当前节点】
3. 寻找中序数组位置作为切割点【根据"中"值，将前中序数组 切割成为 左中序数组 ，右中序数组】
4. 切中序数组
5. 切后序数组【根据上一步切中序数组的结果 将 后序数组切割成左后序数组，右后序数组】
6. 递归处理左中序，左后序，右中序，右后序

/**
 * 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* traversal(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;
        for(index = 0; index < inorder.size();index++){
            if(inorder[index] == rootValue) break;
        }
       //切割，左中序数组，右中序数组  【左闭右开，+ 1是为了跳过中节点】
        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);
    }
};