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

书痴熊

已于 2024-02-24 11:06:33 修改

阅读量144

点赞数

分类专栏：代码随想录训练营文章标签：算法 leetcode c++

于 2022-12-04 14:53:22 首次发布

本文链接：https://blog.csdn.net/xiaohukuzai/article/details/128170345

版权

代码随想录训练营专栏收录该内容

96 篇文章 0 订阅

订阅专栏

Leetcode 513.找树左下角的值
思路分析：
本题直观的思路是层序遍历，可把二叉树的每一层保存在matrix的一层，matrix的最后一层的第一个元素即为数的左下角的值。
当然是用matrix的空间复杂度较高，可以优化，只需使用que队列，保存每层第一个元素，全部执行完，保存的元素就是最底层最左边的节点。

代码实现：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        if (root == nullptr)
            return 0;
        queue<TreeNode*> NodeQueue;
        vector<int> NumVector;
        vector<vector<int>> matrix;
        int result = 0;
        NodeQueue.push(root);
        int next_level = 0;
        int cur_level_remain = 1;
        while (!NodeQueue.empty()) {
            TreeNode* node = NodeQueue.front();
            NumVector.push_back(node->val);
            NodeQueue.pop();
            if (node->left != nullptr) {
                NodeQueue.push(node->left);
                next_level++;
            }
            if (node->right != nullptr) {
                NodeQueue.push(node->right);
                next_level++;
            }
            --cur_level_remain;
            if (cur_level_remain == 0) {
                matrix.push_back(NumVector);
                NumVector.clear();
                cur_level_remain = next_level;
                next_level = 0;
            }
        }
        result = matrix[matrix.size()-1][0];
        return result;

    }
};

优化解法

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        int result = 0;
        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;
    }
};

Leetcode 112. 路径总和
思路分析：
本题可使用递归法和迭代法，本文只给出递归法。

遍历二叉树中是否存在满足条件的路径，一般需要返回值。找到了满足条件的返回true,遍历到叶子节点返回false. 递归法和回溯法配合使用，遍历完一条路径后，要撤回处理结果。另外，判断路径和是否等于targetSum，可以直接在targetsum上操作，判断处理后的targetsum是否为0，且是否遇到叶子节点，如果满足条件，则返回true.

当然本题也可以使用无返回值的递归法，遍历完整的树，只要找到了满足条件的路径，就返回。而且可用局部变量sum实现回溯的功能，不用单独回溯，每层递归里sum值互不影响。

代码实现：
有返回值

class Solution {
private:
    bool traversal(TreeNode* cur, int count) {
        if (!cur->left && !cur->right && count == 0) return true; // 遇到叶子节点，并且计数为0
        if (!cur->left && !cur->right) return false; // 遇到叶子节点直接返回

        if (cur->left) { // 左
            count -= cur->left->val; // 递归，处理节点;
            if (traversal(cur->left, count)) return true;
            count += cur->left->val; // 回溯，撤销处理结果
        }
        if (cur->right) { // 右
            count -= cur->right->val; // 递归，处理节点;
            if (traversal(cur->right, count)) return true;
            count += cur->right->val; // 回溯，撤销处理结果
        }
        return false;
    }

public:
    bool hasPathSum(TreeNode* root, int sum) {
        if (root == NULL) return false;
        return traversal(root, sum - root->val);
    }
};

无返回值

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr)
            return false;
        int sum = 0;
        pathLength(root, sum, targetSum);
        return result;
    }

    void pathLength(TreeNode* node, int sum, int target) {
        sum += node->val;
        if (node->left == nullptr && node->right == nullptr && sum == target) {
            result = true;
            return;
        }
        if (node->left != nullptr) {
            pathLength(node->left,sum,target);
        }
        if (node->right != nullptr) {
            pathLength(node->right,sum,target);
        }
    }
private:
    bool result = false;
};

Leetcode 106.从中序与后序遍历序列构造二叉树
思路分析：
根据中序遍历和后序遍历的性质可知，后序遍历的最后一个元素就是二叉树的root节点，中序遍历中值为root->value的左边为当前root节点的左边子树，右边为当前root节点的右边子树。
可用递归法实现，单层逻辑为根据后序遍历找到root节点，然后根据root节点把中序遍历数组分成leftinorder和rightinorder，再根据leftinorder和rightinorder把后序遍历数组分成leftpostorder和rightpostorder。最后利用递归构建出root的左右节点。最后返回root节点。

代码实现：

class Solution {
public:
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size()==0 || postorder.size()==0) return nullptr;
        return traversal(inorder, postorder);
    }

    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return nullptr;
        int root_value = postorder[postorder.size()-1];
        TreeNode* root = new TreeNode(root_value);
        int root_index_inorder;
        for (int i=0; i < inorder.size(); i++) {
            if (inorder[i] == root_value) {
                root_index_inorder = i;
            }
        }

        vector<int> left_inorder(inorder.begin(), inorder.begin()+root_index_inorder);
        vector<int> right_inorder(inorder.begin()+root_index_inorder+1, inorder.end());

        postorder.resize(postorder.size()-1);

        vector<int> left_postorder(postorder.begin(), postorder.begin()+left_inorder.size());
        vector<int> right_postorder(postorder.begin()+left_inorder.size(), postorder.end());

        root->left = traversal(left_inorder, left_postorder);
        root->right = traversal(right_inorder, right_postorder);
        return root;
    }
};

Leetcode 105.从前序与中序遍历序列构造二叉树
思路分析：
本题可和106.从中序与后序遍历序列构造二叉树相同的方法，前序遍历的第一个元素就是root节点的值，然后在中序遍历中根据root->value区分出左右的数组left_inorder，right_inorder。然后根据left_inorder，right_inorder的大小区分出preorder中左右数组left_preorder和right_preorder。区别每层递归里preorder需要移除的是首元素，106.从中序与后序遍历序列构造二叉树使用的是左闭右开区间，成功避免了末元素，而本题得用erase操作。然后递归计算出root->left和root->right，最后返回root。
因为erase的时间复杂为o(n),在递归中存在o(n)的算法会让时间复杂度随着tree的复杂程度而递增。因此给出方法2，给出每层递归的起始和结束index，其他逻辑一致，可以避免erase操作。

代码实现：

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size()==0 || inorder.size()==0) return nullptr;
        return travesal(preorder, inorder);
    }

    TreeNode* travesal(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size()==0) return nullptr;
        int root_value = preorder[0];
        TreeNode* root = new TreeNode(root_value);
        int root_index_of_inorder;
        for (int i=0; i < inorder.size(); i++) {
            if (inorder[i] == root_value) {
                root_index_of_inorder = i;
            }
        }

        vector<int> left_inorder(inorder.begin(), inorder.begin()+root_index_of_inorder);
        vector<int> right_inorder(inorder.begin()+root_index_of_inorder+1, inorder.end());

        preorder.erase(preorder.begin());

        vector<int> left_preorder(preorder.begin(), preorder.begin()+left_inorder.size());
        vector<int> right_preorder(preorder.begin()+left_inorder.size() ,preorder.end());

        root->left=travesal(left_preorder, left_inorder);
        root->right=travesal(right_preorder, right_inorder);
        return root;
    }
};

优化版

class Solution {
public:
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        if (preorder.size()==0 || inorder.size()==0) return nullptr;
        return traversal(preorder, inorder, 0, 0, inorder.size()-1);
    }

    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder, int preStart, int inStart, int inEnd) {
        if (preStart >= preorder.size() || inStart > inEnd) return nullptr;
        
        int rootValue = preorder[preStart];
        TreeNode* root = new TreeNode(rootValue);
        
        int inorderIndex = -1;
        for (int i = inStart; i <= inEnd; ++i) {
            if (inorder[i] == rootValue) {
                inorderIndex = i;
                break;
            }
        }

        int leftSubtreeSize = inorderIndex - inStart;
        
        root->left = traversal(preorder, inorder, preStart + 1, inStart, inorderIndex - 1);
        root->right = traversal(preorder, inorder, preStart + leftSubtreeSize + 1, inorderIndex + 1, inEnd);
        
        return root;
    }
};