Day18.513.找树左下角的值 112. 路径总和 113(鸽).路径总和ii 106.从中序与后序遍历序列构造二叉树 105(鸽).从前序与中序遍历序列构造二叉树

513.找树左下角的值

1.）层序板子
上该死的记忆，希望不会忘吧！

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root) que.push(root);
        int num=0;
        while(que.empty()!=1)
        {
            int size=que.size();
            for(int i=0;i<size;i++)
            {
                TreeNode* temp=que.front();
                que.pop();
                if(i==0) num=temp->val;//记每层第一个
                if(temp->left) que.push(temp->left);
                if(temp->right) que.push(temp->right);
            }
        }
        return num;
    }
};

2.)递归

class Solution {
public:
    int result;//定义在函数外，主函数要用到
    int max=INT_MIN;//要求最小值
    void getnum(TreeNode* node,int depth)//主要学习思路
    {
        //int max=INT_MAX; 定义到这里每次调用函数时，max重新赋值了，没法连续比较！！！
        if(node==NULL) return;//如果是原始根为空的话，返回[],注意返回类型！
        if(node->left==0&&node->right==0)//说明是叶子节点
        {
            if(depth>max)//判断深度，来进一步确定是否要进行赋值result
             {
                max=depth;//深度交换
                result=node->val;//赋值
             }
             return; //如果交换了数值，跳出当前函数跳出的条件
        }
        if(node->left)//如果node的left节点是真,深度+1,进入node->left的函数
            {
                depth++;
                getnum(node->left,depth);//这里的depth从定义后就开始，直到求出题目要求生命周期结束                
                depth--;//回溯到node节点，判断node节点的left的节点
            }
        if(node->right)//同上
        {
            depth++;
            getnum(node->right,depth);
            depth--;
        }

        return;//如果没有从上面返回，这里便是函数的结束条件
    }
    int findBottomLeftValue(TreeNode* root) {
        getnum(root, 0);//新的知识学习！这里可以传具体数值
        return result;
    }
};

112. 路径总和

1.）递归法（回溯的 再再再 体现）

class Solution {
public:
    bool judge(TreeNode* node,int tempsum)//注意tempsum的值！
    {
        if(node->left == NULL && node->right==NULL )//叶子节点
        {
            if( tempsum == 0) return true;//tempsun==0,返回1
            else return false;//否则返回false；
        }
        if(node->left)
        {
            tempsum-=node->left->val;//先减去这个位置的val
            if( judge(node->left,tempsum) ) return true;//发现匹配路径，返回true
             else tempsum+=node->left->val; //否则的话，回溯tempsun的值
        }
        if(node->right)
        {
            tempsum-=node->right->val;
            if( judge(node->right, tempsum) ) return true;//思路同上
             else tempsum+=node->right->val;
        }
        return false; //直到程序运行完，没有发现匹配的，我们返回false
    
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root==NULL) return false;//在外判断，不用在函数中多次判段
        return judge(root, targetSum - root->val );//输入减去root之后的值开始判断（上面的判断是先决条件）
    }
};

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

递归法
代码如下（有注释）

class Solution {
private:
    TreeNode* get(vector<int>& inorder, vector<int>& postorder)///注意返回类型
    {
        if(postorder.size()==0) return NULL;//没有元素，返回空类型
        int  gene_num=postorder[postorder.size()-1];//后续最后一个元素是根
        TreeNode* root=new TreeNode(gene_num);//temp为存储最后元素的节点！
        if(postorder.size()==1) return root;//如果只有一个元素，返回本身！ 
        int stand;//定义在for外的函数，用来切割位点！
        for(stand=0;stand<postorder.size();stand++)//确定stand！
        {
            if(inorder[stand]==gene_num)
            break;
        }
        //新中序序列
        vector<int> NEW_inorder_left(inorder.begin(),inorder.begin()+stand);
        vector<int> NEW_inorder_right(inorder.begin()+stand+1,inorder.end());//stand加一，跳过我们一已经确定的根!
        postorder.resize(postorder.size()-1);//重构后续数组，去掉root
        //新前序序列
        vector<int> NEW_postorder_left(postorder.begin(),postorder.begin()+NEW_inorder_left.size());//拿前面 新中序数组的长度来切割这个新后序序列（妙啊！）
        vector<int> NEW_postorder_right(postorder.begin()+NEW_inorder_left.size(),postorder.end());//注意begin

        root->left=get(NEW_inorder_left,NEW_postorder_left);
        root->right=get(NEW_inorder_right,NEW_postorder_right);
        return root;
    }
public: 
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if(inorder.size()==0||postorder.size()==0) return NULL;//return 0;要return NULL;
        //注意返回类型！
        return get(inorder,postorder);
    }
};