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

513.找树左下角的值

513. 找树左下角的值 - 力扣（LeetCode）

递归：找到最后一行最左边的值，首先一定是叶子节点，深度最大的叶子节点一定是最后一行，保证优先左边搜索，标记深度，返回最大深度的第一个节点的值就可以了。

class Solution {
public:
    int maxDepth=INT_MIN;           //全局变量  记录最大深度
    int result;                     //全局变量  记录结果
    void travelsal(TreeNode* node,int depth){
        if(node->left==nullptr&&node->right==nullptr){      //叶子节点
            if(depth>maxDepth){         //找到深度最大的叶子节点
                maxDepth=depth;
                result=node->val;
            }
            return;
        }
        if(node->left){
            travelsal(node->left,++depth);      //左子树递归
            depth--;                      //回溯
        }
        if(node->right){
            travelsal(node->right,++depth);     //右子树递归
            depth--;            //回溯
        }
        return;
    }
    int findBottomLeftValue(TreeNode* root) {
        travelsal(root,0);
        return result;
    }
};

迭代：用层序遍历这道题就很好理解了，记录下最后一层的第一个节点的值就OK了。

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root) que.push(root);
        int result;
        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. 路径总和 113.路径总和ii 

首先计数器如何统计这一条路径的和呢？

不要去累加然后判断是否等于目标和，那么代码比较麻烦，可以用递减，让计数器count初始为目标和，然后每次减去遍历路径节点上的数值。

如果最后count == 0，同时到了叶子节点的话，说明找到了目标和。

如果遍历到了叶子节点，count不为0，就是没找到。

本题我们要找一条符合条件的路径，所以递归函数需要返回值，及时返回。

class Solution {
public:
    bool travelsal(TreeNode* node,int count){
        if(!node->left&&!node->right&&count==0) return true;        //判断到了叶子节点且和为目标值 返回true
        if(!node->left&&!node->right) return false;             //否则返回false

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

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

106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

这题感觉比较有难度了。

思路：首先要通过后序数组找到根节点的位置，然后在中序组数中确定根节点的位置，把中序数组切割成左右子树两部分；然后把后续数组最后一个值舍弃，把后续数组也分割成左右子树两个部分，在进行递归。

详细的步骤细节：

• 第一步：如果数组大小为零的话，说明是空节点了。

• 第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

• 第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

• 第四步：切割中序数组，切成中序左数组和中序右数组 （顺序别搞反了，一定是先切中序数组）

• 第五步：切割后序数组，切成后序左数组和后序右数组

• 第六步：递归处理左区间和右区间

class Solution {
private:
    TreeNode* travelsal(vector<int>& inorder, vector<int>& postorder){
            if (postorder.size() == 0) return nullptr;
            int rootvalue=postorder[postorder.size()-1];  //根节点为后续数组最后一个值
            TreeNode* root=new TreeNode(rootvalue);

            if(postorder.size()==1) return root;            //后序数组只有一个节点，说明到叶子节点
            int delimiterIndex;                 //断点，分开左右子树
            for(delimiterIndex=0;delimiterIndex<inorder.size();delimiterIndex++){   //找到断点在中序数组的位置
                if(inorder[delimiterIndex]==rootvalue) break;
            }
            // 切割中序数组
            // 左闭右开区间：[0, delimiterIndex)
            vector<int> leftInorder(inorder.begin(),inorder.begin()+delimiterIndex);        
            vector<int> rightInorder(inorder.begin()+delimiterIndex+1,inorder.end());
            postorder.resize(postorder.size()-1);       // postorder 舍弃末尾元素
            // 切割后序数组
            // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
            vector<int> leftPostorder(postorder.begin(),postorder.begin()+leftInorder.size());
            vector<int> rightPostorder(postorder.begin()+leftInorder.size(),postorder.end());

            root->left=travelsal(leftInorder,leftPostorder);
            root->right=travelsal(rightInorder,rightPostorder);
            return root;
        }
public:
    
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0||postorder.size()==0) return nullptr;
        return travelsal(inorder,postorder);
    }
};