代码随想录第16天|二叉树续

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 findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int value;
        while (!q.empty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode* cur = q.front();
                q.pop();
                if (i == 0)
                    value = cur->val;
                if (cur->left)
                    q.push(cur->left);
                if (cur->right)
                    q.push(cur->right);
            }
        }
        return value;
    }
};

使用递归法：前序遍历，优先向左遍历，如果某个节点为叶子节点且为当前深度最大的时候就记录值

/**
 * 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 = 0;
    int res;
    void getValue(TreeNode* cur, int depth) {
        if (cur->left == nullptr && cur->right == nullptr) {
            if (depth > maxDepth) {
                maxDepth = depth;
                res = cur->val;
            }
            return;
        }
        if (cur->left) {
            getValue(cur->left, depth + 1);
        }
        if (cur->right) {
            getValue(cur->right, depth + 1);
        }
    }
    int findBottomLeftValue(TreeNode* root) {
        getValue(root, 1);
        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:
    bool Check(TreeNode* cur, int targetSum, int sum) {
        if (cur->left == nullptr && cur->right == nullptr) {
            if (sum + cur->val == targetSum)
                return true;
            return false;
        }
        bool left = false, right = false;
        if (cur->left)
            left = Check(cur->left, targetSum, sum + cur->val);
        if (cur->right)
            right = Check(cur->right, targetSum, sum + cur->val);
        return left || right;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)
            return false;
        return Check(root, targetSum, 0);
    }
};

113.路径总和2

/**
 * 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;
    void getPath(TreeNode* cur, int targetSum, int sum, vector<int> r) {
        if (cur->left == nullptr && cur->right == nullptr) {
            if (sum + cur->val == targetSum) {
                r.push_back(cur->val);
                res.push_back(r);
            }
            return;
        }
        if (cur->left) {
            r.push_back(cur->val);
            getPath(cur->left, targetSum, sum + cur->val, r);
            r.pop_back();
        }
        if (cur->right) {
            r.push_back(cur->val);
            getPath(cur->right, targetSum, sum + cur->val, r);
            r.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<int> r;
        if (root == nullptr)
            return res;
        getPath(root, targetSum, 0, r);
        return res;
    }
};

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

首先先从后序遍历的最后一个元素获取根节点’3’
根据这个3，在中序遍历里找到分割点，于是中序数组变成[9]和[15,20,7]
因为分割后的中序左数组和右数组的大小是和后序分割后的左数组和右数组是一样的，所以我们在把后序数组的最后一个元素删除后，通过分割的两个中序数组的大小来分割后序数组
后面递归的进行这个操作，直到遇见的数组大小为0或为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:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0 || inorder.size() == 0)
            return nullptr;
        int rootv = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootv);
        if (postorder.size() == 1)
            return root;

        int divide;
        for (divide = 0; divide < inorder.size(); divide++) {
            if (inorder[divide] == rootv)
                break;
        }
        vector<int> leftinorder(inorder.begin(), inorder.begin() + divide);
        vector<int> rightinorder(inorder.begin() + divide + 1, inorder.end());
        postorder.resize(postorder.size() - 1);

        vector<int> leftpostorder(postorder.begin(),
                                  postorder.begin() + leftinorder.size());
        // 因为之前postorder已经resize过了，所以这里末尾是.end() 把根删除了
        vector<int> rightpostorder(postorder.begin() + leftinorder.size(),
                                   postorder.end());
        root->left = buildTree(leftinorder, leftpostorder);
        root->right = buildTree(rightinorder, rightpostorder);
        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) {
        if (preorder.size() == 0 || inorder.size() == 0)
            return nullptr;
        int rootvalue = preorder[0];
        TreeNode* root = new TreeNode(rootvalue);
        if (preorder.size() == 1)
            return root;
        int divide;
        for (divide = 0; divide < inorder.size(); divide++) {
            if (inorder[divide] == rootvalue)
                break;
        }
        vector<int> leftinorder(inorder.begin(), inorder.begin() + divide);
        vector<int> rightinorder(inorder.begin() + divide + 1, inorder.end());
        preorder.erase(preorder.begin());
        vector<int> leftpreorder(preorder.begin(),
                                 preorder.begin() + leftinorder.size());
        vector<int> rightpreorder(preorder.begin() + leftinorder.size(),
                                  preorder.end());
        root->left = buildTree(leftpreorder, leftinorder);
        root->right = buildTree(rightpreorder, rightinorder);
        return root;
    }
};