二叉树：找树左下角的值路径总和从中序与后序遍历序列构造二叉树

暁_

已于 2023-11-28 14:47:06 修改

阅读量380

点赞数 8

文章标签：数据结构算法 leetcode

于 2023-11-28 13:54:52 首次发布

本文链接：https://blog.csdn.net/m0_59425585/article/details/134665023

版权

找树左下角的值

题目：Leetcode513
思路：
- 递归：首先要是最后一行，然后是最左边的值。使用递归法判断是否是最后一行，只需找到深度最大的叶子节点，就一定是最后一行。寻找最左边的值，可以使用前序遍历，保证左边优先搜索，然后记录深度最大的叶子节点，此时就是树的最后一行最左边的值。在找最大深度的时候，递归的过程中依然要使用回溯。
- 迭代：层序遍历，只需要记录最后一行第一个节点的数值。

//递归
class Solution {
public:
    int maxDepth = INT_MIN;
    int result;

    void traversal(TreeNode* node, int depth) {
        //终止条件
        if(node->left == NULL && node->right == NULL) {
            if(depth > maxDepth) {
                maxDepth = depth;//更新最大深度
                result = node->val;
            }
        }
        //单层逻辑，没有 中 ，因为 中 没有需要处理的逻辑，因此前/中/后序都相同
        if(node->left) {    //左
            // traversal(node->left, depth + 1);//代码精简，隐藏回溯
            depth++;
            traversal(node->left, depth);
            depth--;//回溯
        }
        if(node->right) {   //右
            // traversal(node->right, depth + 1);//代码精简，隐藏回溯
            depth++;
            traversal(node->right, depth);
            depth--;//回溯
        }
        return;
    }

    int findBottomLeftValue(TreeNode* root) {
        traversal(root, 0);
        return result;
    }
};


//迭代
class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if(root == nullptr) return 0;
        que.push(root);
        int res;
        while(!que.empty()) {
            int size = que.size();
            for(int i = 0; i < size; i++) {
                TreeNode* node = que.front();
            que.pop();
            if(i == 0) res = node->val;//记录最左边元素，每层不断覆盖，最终值就是最后一层最左边的元素值
            if(node->left) que.push(node->left);
            if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};

路径总和

题目：Leetcode112,113
思路：
- 递归。本题前中后序都可以，因为中节点没有处理逻辑。
- 与其使用一个变量来累加数值最后再比较，不如再参数中加入一个int类型计数器，初始化为目标和，用来计算二叉树的一条边之和是否正好是目标和：遍历过程中依次减去路径中节点的值，若到达叶子节点时，计数器刚好减到0，则说明该路径符合要求。否则，则需要进行回溯。
- 112只需要判断是否存在这样的路径，因此不需要遍历整棵树，递归函数需要返回值bool类型；113.路径总和ii要遍历整个树，找到所有路径，所以递归函数不要返回值。

class Solution {
public:
    bool traversal(TreeNode* node, int count) {
        if(!node->left && !node->right && count == 0) return true;
        if(!node->left && !node->right && count != 0) return false;

        if(node->left) {
            //隐藏了回溯逻辑
            if(traversal(node->left, count - node->left->val))
                return true;
        }
        if(node->right) {
            if(traversal(node->right, count - node->right->val))
                return true;
        }
        return false;
    }

    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr) return false;
        return traversal(root, targetSum - root->val);
    }
};

class Solution {
public:
    
    vector<vector<int>> res;
    vector<int> vec;
    void traversal(TreeNode* node, int count) {
        if(!node->left && !node->right && count == 0) { //符合条件的情况
            res.push_back(vec);
            return;
        }
        if(!node->left && !node->right && count != 0) return;//不合符直接返回

        if(node->left) {
            count -= node->left->val;
            vec.push_back(node->left->val);
            traversal(node->left, count);//递归
            vec.pop_back();//回溯
            count += node->left->val;//回溯
        }
        if(node->right) {
            count -= node->right->val;
            vec.push_back(node->right->val);
            traversal(node->right, count);//递归
            vec.pop_back();//回溯
            count += node->right->val;//回溯
        }
        return;
    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        res.clear();
        vec.clear();
        if(root == nullptr) return res;
        vec.push_back(root->val);//把根节点值放入路径
        traversal(root, targetSum - root->val);
        return res;
    }
};

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

题目：Leetcode106,105
思路：
- 以后序数组的最后一个元素为切割点，先切中序数组，根据中序数组，反过来再切后序数组。一层一层切下去，每次后序数组最后一个元素就是节点元素。
- 递归：
  1. 后序数组为0，说明为空节点；
  2. 后续数组最后一个元素为节点元素；
  3. 寻找该节点元素在中序数组的位置，作为切割点；
  4. 切分中序数组 → 中序左数组&中序右数组
  5. 切分后续数组 → 中序左数组&中序右数组
  6. 递归处理左、右区间
- 难点：如何切割 & 边界值处理
  - 首先切割中序数组，因为切割点在后序数组的最后一个元素，而除此之外无法分辨后序数组中其他元素哪些为左子树上的哪些是右子树上的，所以必须先切割中序数组。
  - 后序数组没有明确的切割元素来进行左右切割，此时有一个关键的点，就是中序数组大小一定是和后序数组的大小相同的（这是必然）。切割完中序数组，不难得到左右子树数组的大小，后序数组就可以按照左中序数组的大小来切割，切成左后序数组和右后序数组。
  - 此时，中序数组切成了左中序数组和右中序数组，后序数组切割成左后序数组和右后序数组，就可以开始递归。
  - 边界处理：统一左闭右开原则。

class Solution {
private:
    TreeNode* traversal (vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) return NULL;

        // 后序遍历数组最后一个元素，就是当前的中间节点
        int rootValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(rootValue);

        // 叶子节点
        if (postorder.size() == 1) return root;

        // 找到中序遍历的切割点
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++) {
            if (inorder[delimiterIndex] == rootValue) break;
        }

        // 切割中序数组
        // 左闭右开区间：[0, delimiterIndex)
        vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
        // [delimiterIndex + 1, end)
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end() );

        // postorder 舍弃末尾元素
        postorder.resize(postorder.size() - 1);

        // 切割后序数组
        // 依然左闭右开，注意这里使用了左中序数组大小作为切割点
        // [0, leftInorder.size)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + leftInorder.size());
        // [leftInorder.size(), end)
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(), postorder.end());

        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

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