算法第14天|继续学习二叉树：找二叉树左下角的值、二叉树路径总和、从中序遍历与后序遍历序列构建二叉树

今日总结：

        1、找二叉树左下角的值：递归法重新思考；迭代法就是模板

        2、二叉树路径和：

                求匹配，如果题目要求匹配就结束，在递归中需要返回值，来提前结束寻找；

                如果题目中要求遍历二叉树，不能提前结束寻找，使用res记录无需返回值。

        3、从中序遍历与后序遍历序列构建二叉树：

                需要反复思考递归的返回、输入、停止、单次逻辑

找二叉树左下角的值

题目链接：513. 找树左下角的值 - 力扣（LeetCode）

整体思路：

        二叉树左下角的值其实本质上就是最后一层的第一个值

        思路1：使用层序遍历迭代法，获取获取每一层的第一个值，覆盖掉上一层的第一个值。

        迭代法代码：

/*** 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 res;if(root==nullptr)return 0;que.push(root);while(!que.empty()){int size =que.size();for(int i=0;i<size;i++){TreeNode* cur =que.front();que.pop();//每一层从左到右，只需要找到最后一层的第一个，所以res获取当前层的第一个，循环到最后一层覆盖掉每一层的res就行if(i==0) res = cur->val;if(cur->left!=nullptr)que.push(cur->left);if(cur->right!=nullptr)que.push(cur->right);}}return res;}
};

        思路2：使用递归法：本质上其实在找最深层的第一个节点，深度是从根节点到叶子节点->从上往下->使用前序遍历+回溯的方法

                1、确定递归的返回参数、传入参数

                        找二叉树的深度的时候，是从上往下，不易使用返回值记录每一层的特点，而是直接使用一个变量去记录便于回溯。

                        传入当前节点、深度，使用一个全局深度与当前层深度（从-1开始，因为0层表示叶子节点）对比

    int max_depth=-1;int res;//递归遍历//1、确定返回值、输入参数//因为是求最下边的最左节点，深度使用前序遍历+回溯//无需返回值，深度是从上往下底层，不易返回，使用一个变量记录，与全局深度比较//输入参数：当前节点,深度（与全局深度比较）void digui(TreeNode* root,int depth)

                2、确定递归的停止条件

                        前序遍历->寻找最下边的某些东西，停止条件满足后->意味指到达最下边，需要记录满足的东西，之后进行回溯

                        这里到达叶子节点后：需要判断深度与最大深度的关系，决定左下角节点的值的变化

        //2、确定停止条件//寻找左节点，前序遍历会记录当前位置，所以只需要到叶子节点if(root->left==nullptr&&root->right==nullptr)//叶子节点，需要记录与判断{//判断深度，因为是优先左节点，再右节点，只有深度变化，才会记录最左边的值if(max_depth<depth){res = root->val;max_depth =depth;//更新最大深度} }

                3、确定递归的单层逻辑循环

                        前序遍历：中左右，中无需记录，直接跳过，左遍历，回溯，右遍历，回溯

        //3、确定单层循环逻辑//中左右//不需要记录中，因为在寻找最下的元素//递归左,没有判断是不是空，所以需要自己判断if(root->left!=nullptr){//深度depth++;//递归digui(root->left,depth);//回溯depth--;}//递归右,没有判断是不是空，所以需要自己判断if(root->right!=nullptr){//深度depth++;//递归digui(root->right,depth);//回溯depth--;}

        递归法代码：

/*** 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 max_depth=-1;int res;//递归遍历//1、确定返回值、输入参数//因为是求最下边的最左节点，深度使用前序遍历+回溯//无需返回值，深度是从上往下底层，不易返回，使用一个变量记录，与全局深度比较//输入参数：当前节点,深度（与全局深度比较）void digui(TreeNode* root,int depth){//2、确定停止条件//寻找左节点，前序遍历会记录当前位置，所以只需要到叶子节点if(root->left==nullptr&&root->right==nullptr)//叶子节点，需要记录与判断{//判断深度，因为是优先左节点，再右节点，只有深度变化，才会记录最左边的值if(max_depth<depth){res = root->val;max_depth =depth;//更新最大深度} }//3、确定单层循环逻辑//中左右//不需要记录中，因为在寻找最下的元素//递归左,没有判断是不是空，所以需要自己判断if(root->left!=nullptr){//深度depth++;//递归digui(root->left,depth);//回溯depth--;}//递归右,没有判断是不是空，所以需要自己判断if(root->right!=nullptr){//深度depth++;//递归digui(root->right,depth);//回溯depth--;}}int findBottomLeftValue(TreeNode* root) {digui(root,0);return res;        }
};

二叉树路径总和（存在即可）

题目链接：112. 路径总和 - 力扣（LeetCode）

整体思路：

        求路径匹配，可以使用前序遍历+回溯（递归）

        1、确定递归的返回参数、传入参数

        返回参数：因为这个题要求匹配后就可以输出答案，所以返回true\false

        传入参数：当前节点、匹配值、当前的和（通过设置全局和无需传入）

    int sum = 0;//寻找路径，可以使用前序遍历+回溯//1、确定递归返回值，输入值//返回值：如果//输入值：当前节点,一个sum，用于记录当前路径的和,目标值,bool digui(TreeNode* root,int &targetSum)

        2、确定递归的停止条件

        停止条件：前序遍历，一般在获取叶子节点后开始判断记录

        （1）首先刚到叶子节点，需要将叶子节点的值加入到sum中

        （2）判断sum是不是==目标值

        （3）等于返回true，不等于返回false

        

        //2、确定停止条件//当遇到叶子节点，表示当前路径寻找完毕，需要判断当前路径是不是等于目标值if(root->left==nullptr&&root->right==nullptr){sum += root->val;if(sum == targetSum){return true;}else {return false;}     }

        3、确定单层递归条件：

        前序遍历+回溯：

        （1）中：首先将当前节点值加入到sum中；

        （2）左：递归左子节点，如果左子节点的返回值是true，直接返回true，如果是false需要回溯，往下运行

        （3）右：递归右子节点，如果右子节点的返回值是true，直接返回true，如果是false需要回溯，往下运行

        （4）最后，返回false，因为左右子节点递归都不满足

        //3、确定单层递归逻辑//前序遍历+回溯，中左右，记录sumsum += root->val;//记录当前节点的值//左子节点遍历，因为没有保护左子节点==nullptr，需要在这里设置if(root->left!=nullptr) {if(digui(root->left,targetSum)==true) return true;//如果没找到，回溯sum -= root->left->val;}if(root->right!=nullptr) {if(digui(root->right,targetSum)==true)return true;//如果没找到，回溯sum -= root->right->val;}return false;

递归代码：

/*** 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 sum = 0;//寻找路径，可以使用前序遍历+回溯//1、确定递归返回值，输入值//返回值：如果//输入值：当前节点,一个sum，用于记录当前路径的和,目标值,bool digui(TreeNode* root,int &targetSum){//2、确定停止条件//当遇到叶子节点，表示当前路径寻找完毕，需要判断当前路径是不是等于目标值if(root->left==nullptr&&root->right==nullptr){sum += root->val;if(sum == targetSum){return true;}else {return false;}     }//3、确定单层递归逻辑//前序遍历+回溯，中左右，记录sumsum += root->val;//记录当前节点的值//左子节点遍历，因为没有保护左子节点==nullptr，需要在这里设置if(root->left!=nullptr) {if(digui(root->left,targetSum)==true) return true;//如果没找到，回溯sum -= root->left->val;}if(root->right!=nullptr) {if(digui(root->right,targetSum)==true)return true;//如果没找到，回溯sum -= root->right->val;}return false;}bool hasPathSum(TreeNode* root, int targetSum) {if(root==nullptr)return false;return digui(root,targetSum);}
};

 二叉树路径总和（全部路径）

题目链接：113. 路径总和 II - 力扣（LeetCode）

整体思路：

        与上一题不同，这个是匹配所有的路径，所以需要遍历整棵二叉树，将满足的路径保存，所以不需要返回值，但是同样的思路：前序遍历+回溯

        1、确定递归返回值、输入值

        返回值：因为是遍历整棵二叉树，记录路径使用全局变量vector，无需返回值

        输入值：当前节点、目标值

    //1、确定返回值、输入值//返回值：无需返回值，路径使用全局变量记录//输入值：当前节点、目标值、（当前值为多少也使用全局变量记录，当前路径也使用全局变量记录）void digui(TreeNode* root,int targetSum){

        2、确定递归停止条件

        因为是前序遍历+回溯寻找路径，找到叶子节点就可以停止，开始将当前路径判断和是不是等于目标值，等于目标值记录，不等于目标值舍弃

//2、确定停止条件//停止条件：叶子节点就记录路径、判断路径和if(root->left==nullptr&&root->right==nullptr){//存储当前的叶子节点sum +=root->val;path.push_back(root->val);//判断是不是等于目标和if(sum ==targetSum){//记录到res中res.push_back(path);return;}//如果不是，就returnreturn ;}

        3、确定递归的单层循环逻辑

        前序遍历+回溯：

        路径中加入当前节点

        递归左子节点，回溯

        递归右子节点，回溯

//3、确定单层递归逻辑//记录中节点sum+=root->val;path.push_back(root->val);//递归左右节点，在左右节点！=nullptr下if(root->left!=nullptr) {digui(root->left,targetSum);//回溯sum -=root->left->val;path.pop_back();}if(root->right!=nullptr) {digui(root->right,targetSum);//回溯sum -=root->right->val;path.pop_back();}return ;

        递归代码

/*** 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;vector<int>path;int sum=0;//1、确定返回值、输入值//返回值：无需返回值，路径使用全局变量记录//输入值：当前节点、目标值、（当前值为多少也使用全局变量记录，当前路径也使用全局变量记录）void digui(TreeNode* root,int targetSum){//2、确定停止条件//停止条件：叶子节点就记录路径、判断路径和if(root->left==nullptr&&root->right==nullptr){//存储当前的叶子节点sum +=root->val;path.push_back(root->val);//判断是不是等于目标和if(sum ==targetSum){//记录到res中res.push_back(path);return;}//如果不是，就returnreturn ;}//3、确定单层递归逻辑//记录中节点sum+=root->val;path.push_back(root->val);//递归左右节点，在左右节点！=nullptr下if(root->left!=nullptr) {digui(root->left,targetSum);//回溯sum -=root->left->val;path.pop_back();}if(root->right!=nullptr) {digui(root->right,targetSum);//回溯sum -=root->right->val;path.pop_back();}return ;}vector<vector<int>> pathSum(TreeNode* root, int targetSum) {//确保root不空if (root==nullptr)return res;digui(root,targetSum);return res;}
};

从中序遍历与后序遍历序列构建二叉树

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

整体思路：

        中序：左中右

        后序：左右中

        通过后序数组的最后一位可以获得中间的节点，在中序数组中找到中间节点，左边的就是左子树，右边的就是右子树-->将中序数组通过中点分割成左中序数组、右中序数组，同样将后序数组的最后一位（当前中间节点）去掉，将后序数组分为左后序数组、右后序数组（根据左右子树元素相等）之后进行递归。。。

        1、确定递归的返回参数、传入参数

        返回参数：最终要求返回的是构造的二叉树，所以要返回每一次的节点

        传入参数：传入每次划分的中序数组、后序数组

//递归获取每一个位置上的节点：//1、确定递归的输入参数、返回参数//返回参数：返回根节点的完整二叉树//输入参数：后序遍历数组、中序遍历数组TreeNode* digui(vector<int>& inorder,vector<int>&postorder)

         2、确定递归的停止条件

        当中序（后序）数组为空，就返回nullptr，表示叶子节点下边的空节点

if(postorder.size()==0)return nullptr;

         3、确定单层递归逻辑：

        (1)获取后序遍历数组的尾元素，作为中间节点

        //(1)获取后序遍历数组的尾元素-->中间节点TreeNode* root = new TreeNode();root->val = postorder[postorder.size()-1];

         （2）切割中序数组，从中间节点分成左中序数组、右中序数组。同理（左子树元素不变）切割左后序数组、右后序数组

        for(;i<inorder.size();i++){if (inorder[i] == root->val)break;//此时i就是中间节点在中序遍历数组中的下标位置}vector<int>left_inorder (inorder.begin(),inorder.begin()+i);//将中序遍历数组切割成左中序遍历数组，开始到i的前一位,注意是左闭右开vector<int>right_inorder (inorder.begin()+i+1,inorder.end());//将中序遍历数组切割成右中序遍历数组，中序遍历数组的i后第一位置，到最后//切割后序遍历数组，中序、后序的数组子树元素相同vector<int>left_postorder (postorder.begin(),postorder.begin()+i);vector<int>right_postorder (postorder.begin()+i,postorder.end()-1);

        （3）递归左右子节点，将值赋给root->left,root->right,返回root

//递归左子树，递归右子树root->left = digui(left_inorder,left_postorder);root->right =digui(right_inorder,right_postorder); return 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://递归获取每一个位置上的节点：//1、确定递归的输入参数、返回参数//返回参数：返回根节点的完整二叉树//输入参数：后序遍历数组、中序遍历数组TreeNode* digui(vector<int>& inorder,vector<int>&postorder){//2、确定递归的停止条件：//如果后序遍历数组是空的，表示根节点是nullptrif(postorder.size()==0)return nullptr;//3、确定单层递归逻辑//(1)获取后序遍历数组的尾元素-->中间节点TreeNode* root = new TreeNode();root->val = postorder[postorder.size()-1];//(2)切割中序遍历数组，从开始到中间节点之前、中间结点之后到结束int i = 0;for(;i<inorder.size();i++){if (inorder[i] == root->val)break;//此时i就是中间节点在中序遍历数组中的下标位置}vector<int>left_inorder (inorder.begin(),inorder.begin()+i);//将中序遍历数组切割成左中序遍历数组，开始到i的前一位,注意是左闭右开vector<int>right_inorder (inorder.begin()+i+1,inorder.end());//将中序遍历数组切割成右中序遍历数组，中序遍历数组的i后第一位置，到最后//切割后序遍历数组，中序、后序的数组子树元素相同vector<int>left_postorder (postorder.begin(),postorder.begin()+i);vector<int>right_postorder (postorder.begin()+i,postorder.end()-1);//递归左子树，递归右子树root->left = digui(left_inorder,left_postorder);root->right =digui(right_inorder,right_postorder); return root;}TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {return digui(inorder,postorder);}
};