【代码随想录】day18

最新推荐文章于 2024-07-24 22:13:06 发布

weixin_47041555

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量292

点赞数 7

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

本文链接：https://blog.csdn.net/weixin_47041555/article/details/136724244

版权

本文介绍了使用迭代和递归方法解决513题的树左下角值问题，以及112和113路径总和问题的算法。同时探讨了106和105中从中序和后序/前序遍历序列构建二叉树的方法。

摘要由CSDN通过智能技术生成

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、513找树左下角的值

迭代法：

class Solution {
public:
    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> q;
        q.push(root);
        int res = root->val;
        while (! q.empty()) {
            int n = q.size();
            res = q.front()->val;
            while (n --) {
                TreeNode* node = q.front();
                q.pop();
                if (node->left) {
                    q.push(node->left);
                }
                if (node->right) {
                    q.push(node->right);
                }
            }
        }
        return res;
    }
};

递归法：

class Solution {
public:
    int maxDepth = INT_MIN;
    int result;
    void traversal(TreeNode* node, int height) {
        if (node->left == nullptr && node->right == nullptr) {
            if (height > maxDepth) {
                maxDepth = height;
                result = node->val;
            }
            return;
        }
        if (node->left) {
            height ++;
            traversal(node->left, height);
            height --;
        }
        if (node->right) {
            height ++;
            traversal(node->right, height);
            height --;
        }
    }


    int findBottomLeftValue(TreeNode* root) {
        //左下角的上一层结点的高度
        traversal(root, 0);
        return result;
    }
};

二、112路径总和

class Solution {
public:
    bool res = false;
    void traversal(TreeNode* node, int target) {
        if (node == nullptr) {
            return;
        }
        if (target == 0 && node->left == nullptr && node->right == nullptr) {
            res = true;
            return;
        }
        if (node->left) {
            target -= node->left->val;
            traversal(node->left, target);
            target += node->left->val;
        }
        if (node->right) {
            target -= node->right->val;
            traversal(node->right, target);
            target += node->right->val;
        }
    }
    
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == nullptr) return false;
        targetSum -= root->val;
        traversal(root, targetSum);
        return res;
    }
};

三、113路径总和ii

class Solution {
public:
    void traversal(vector<vector<int>>& res, vector<int>& path, int count, TreeNode* node) {
        if (node == nullptr) return;
        if (count == 0 && node->left == nullptr && node->right == nullptr) {
            res.push_back(path);
        }
        if (node->left) {
            path.push_back(node->left->val);
            traversal(res, path, count - node->left->val, node->left);
            path.pop_back();
        }
        if (node->right) {
            path.push_back(node->right->val);
            traversal(res, path, count - node->right->val, node->right);
            path.pop_back();
        }
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        vector<vector<int>> res;
        if (root == nullptr) return res;
        vector<int> path;
        path.push_back(root->val);
        traversal(res, path, targetSum - root->val, root);
        return res;
    }
};

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

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        int n = postorder.size();
        if (n == 0) return nullptr;
        int rootVal = postorder[n-1];
        TreeNode* root = new TreeNode(rootVal);
        if (n == 1) return root;
        //在中序中找root
        int index;
        for (index = 0; index < n; index ++) {
            if (inorder[index] == rootVal) {
                break;
            }
        }
        //左中：[0,index）右中[index+1, n)
        vector<int> leftInorder(inorder.begin(), inorder.begin()+index);
        vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());
        //左后:[0, index)，右后[index,n-1)
        vector<int> leftPostorder(postorder.begin(), postorder.begin() + index);
        vector<int> rightPostorder(postorder.begin() + index, postorder.end() - 1);
        root->left = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder);
    }
};

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

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, vector<int>& inorder) {
        int n = preorder.size();
        if (n == 0) return nullptr;
        int rootVal = preorder[0];
        TreeNode* root = new TreeNode(rootVal);
        if (n == 1) return root;
        //在中序中找root
        int index = 0;
        for (; index < n; index ++) {
            if (inorder[index] == rootVal) {
                break;
            }
        }
        //切分中序,左中
        vector<int> leftInorder(inorder.begin(), inorder.begin()+index);
        vector<int> rightInorder(inorder.begin() + index + 1, inorder.end());
        //切分前序
        vector<int> leftPreorder(preorder.begin()+1, preorder.begin()+index+1);
        vector<int> rightPreorder(preorder.begin()+index+1, preorder.end());
        root->left = traversal(leftPreorder, leftInorder);
        root->right = traversal(rightPreorder, rightInorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        return traversal(preorder, inorder);
    }
};