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

513. 找树左下角的值

/**
 * 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 maxdepth = -1;
    int res;
    void mufun(TreeNode* cur , int depth)
    {
        if(cur -> left == NULL && cur -> right == NULL)
        {
            if(depth > maxdepth)
            {
                maxdepth = depth;
                res = cur -> val;
            }
        } 
        if(cur -> left)
        {
            depth++;
            mufun(cur -> left , depth);
            depth--;
        }
        if(cur -> right)
        {
            depth++;
            mufun(cur -> right , depth);
            depth--;
        }

    }
    int findBottomLeftValue(TreeNode* root) {
        mufun(root , 0);
        return res;
    }
};

112. 路径总和

/**
 * 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 res = 0;
    void myfun(TreeNode* cur, int targetSum)
    {
        if(cur -> val == targetSum && cur -> left == NULL && cur -> right == NULL) 
        {
            res = 1;
            return;
        }
        if(cur -> left) myfun(cur -> left, targetSum - cur -> val);
        if(cur -> right) myfun(cur -> right , targetSum - cur -> val);
        
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == NULL) return res;
        myfun(root , targetSum);
        return res;
    }
};

113. 路径总和 II

/**
 * 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> temp;
    void myfun(TreeNode* cur, int targetSum)
    {
        if(cur -> val == targetSum && cur -> left == NULL && cur -> right == NULL) 
        {
            temp.push_back(cur -> val);
            res.push_back(temp);
            temp.pop_back();
            return;
        }
        if(cur -> left) 
        {
            temp.push_back(cur -> val);
            myfun(cur -> left, targetSum - cur -> val);
            temp.pop_back();
        }
        if(cur -> right) 
        {
            temp.push_back(cur -> val);
            myfun(cur -> right , targetSum - cur -> val);
            temp.pop_back();
        }
        
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {

        if(root == NULL) return res;
        myfun(root , targetSum);
        return res;
    }
};

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

/**
 * 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* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int len = inorder.size();
        if(len == 0) return NULL;
        TreeNode* root = new TreeNode(postorder[len -1]);
        int flag = 0;
        for(int i = 0 ; i < len ; i++)
        {
            if(inorder[i] == postorder[len -1])
            {
                flag = i;
                break;
            }
        }
        if(flag > 0)
        {
            vector <int> myin (inorder.begin() , inorder.begin() + flag);
            vector <int> myout (postorder.begin() , postorder.begin() + flag);
            root -> left = buildTree(myin , myout);
        }
        if(flag < len -1 )
        {
            vector <int> myin (inorder.begin() +flag + 1, inorder.end());
            vector <int> myout (postorder.end() + flag - len, postorder.end() - 1);
            root -> right = buildTree(myin , myout);
        }
        return root;
    }
};

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

/**
 * 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* buildTree(vector<int>& preorder, vector<int>& inorder) {
        TreeNode* root = new TreeNode(preorder[0]); 
        int flag = 0;
        int len = preorder.size();
        if(len == 0) return NULL;
        for(int i = 0 ; i < len ;i++)
        {
            if(inorder[i] == preorder[0])
            {
                flag = i;
                break;
            }
        } 
        if(flag > 0)
        {
            vector<int> mypre (preorder.begin() + 1 , preorder.begin() + flag + 1);
            vector<int> myin (inorder.begin() , inorder.begin() + flag);
            root -> left = buildTree(mypre , myin);
        }
        if(flag < len -1)
        {
            vector<int> mypre (preorder.begin() + 1 + flag , preorder.end());
            vector<int> myin (inorder.begin() + 1 + flag , inorder.end());
            root -> right = buildTree(mypre , myin);
        }
        return root;
    }
};