代码随想录刷题第18天

最新推荐文章于 2024-09-14 18:52:56 发布

太阳照常升起366

最新推荐文章于 2024-09-14 18:52:56 发布

阅读量562

点赞数 15

文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/weixin_74090791/article/details/135886897

版权

第一题是找树左下角的值https://leetcode.cn/problems/find-bottom-left-tree-value/description/，没啥思路。看看题解代码随想录。卡哥提到了层序遍历，上手写一下，一遍整出。

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

递归方法通过更新叶子结点的深度值，先遍历左，后遍历右，保证找到的第一个深度最大的叶子结点是最后一行最左侧的点。

class Solution {
public:
    int maxdepth = INT_MIN;
    int result;
    void travel(TreeNode* node, int depth) { //确定递归函数的参数和返回值
        if (node->left == NULL && node->right == NULL) { //确定终止条件
            if (maxdepth < depth) {
                maxdepth = depth;
                result = node->val;
            }
            return;
        }
        if (node->left) { //确定单层递归逻辑
            depth++;
            travel(node->left, depth);
            depth--; //回溯，返回上层
        }
        if (node->right) {
            depth++;
            travel(node->right, depth);
            depth--;
        }
        return;
    }

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

拿下。

第二题是路径总和https://leetcode.cn/problems/path-sum/description/，有点想法了，写了一遍发现细节还是不清楚，如何由下向上返回判断结果。看题解才写出来第一遍代码。

class Solution {
public:
    bool travel(TreeNode* node, int count) { //确定递归函数的参数与返回类型//
        if (node->left == NULL && node->right == NULL && count == 0)
            return true;
        if (node->left == NULL && node->right == NULL && count != 0)
            return false; //终止递归逻辑//
        if (node->left) {
            count -= node->left->val;
            if (travel(node->left, count))
                return true; //向上返回true//
            count += node->left->val;
        }
        if (node->right) {
            count -= node->right->val;
            if (travel(node->right, count))
                return true;
            count += node->right->val; //回溯//
        }
        return false;
    }
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL)
            return false;
        return travel(root, targetSum - root->val);
    }
};

迭代用栈也是可以的。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (root == NULL)
            return false;
        stack<pair<TreeNode*, int>> st;
        st.push(pair<TreeNode*, int>(root, root->val));
        while (!st.empty()) {
            pair<TreeNode*, int> node = st.top();
            st.pop();
            if (!node.first->left && !node.first->right &&
                targetSum == node.second)
                return true;
            if (node.first->right)
                st.push(pair<TreeNode*, int>(
                    node.first->right, node.second + node.first->right->val));
            if (node.first->left)
                st.push(pair<TreeNode*, int>(
                    node.first->left, node.second + node.first->left->val));
        }
        return false;
    }
};

相似题目是https://leetcode.cn/problems/path-sum-ii/，不过此题需要我们遍历整颗树，因此递归函数不需要返回值。

class Solution {
public:
    vector<vector<int>> result;
    vector<int> path;
    void travel(TreeNode* node, int count) {
        if (!node->left && !node->right && count == 0) {
            result.push_back(path);
            return;
        }
        if (!node->left && !node->right)
            return;
        if (node->left) {
            path.push_back(node->left->val);
            count -= node->left->val;
            travel(node->left, count);
            count += node->left->val;
            path.pop_back();
        }
        if (node->right) {
            path.push_back(node->right->val);
            count -= node->right->val;
            travel(node->right, count);
            count += node->right->val;
            path.pop_back();
        }
        return;
    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        result.clear();
        path.clear();
        if (root == NULL)
            return result;
        path.push_back(root->val);
        travel(root, targetSum - root->val);
        return result;
    }
};

第三题是构造二叉树力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台，直接上卡哥讲解。重点在于切割两个数组，再对切割结果进行递归。

class Solution {
public:
    TreeNode* travel(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;
        }
        vector<int> leftInorder(inorder.begin(),
                                inorder.begin() +
                                    delimiterIndex); //确定中序左子树//
        vector<int> rightInorder(inorder.begin() + delimiterIndex + 1,
                                 inorder.end()); //确定中序右子树//
        postorder.resize(postorder.size() - 1);  //丢最后一个数组//
        vector<int> leftPostorder(postorder.begin(),
                                  postorder.begin() +
                                      leftInorder.size()); //确定后序左子树//
        vector<int> rightPostorder(postorder.begin() + leftInorder.size(),
                                   postorder.end()); //确定后序右子树//
        root->left = travel(leftInorder, leftPostorder);
        root->right = travel(rightInorder, rightPostorder);
        return root;
    }
    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        if (inorder.size() == 0 || postorder.size() == 0)
            return NULL;
        return travel(inorder, postorder);
    }
};

下标法规避了建立vector的麻烦。

class Solution {
public:
    TreeNode* travel(vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd){
        if (postorderBegin == postorderEnd) return NULL;
        int rootValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(rootValue);
        if (postorderBegin - postorderEnd == 1) return root;
        int delimiterIndex;
        for(delimiterIndex = 0; delimiterIndex < inorderEnd; delimiterIndex++){
            if (inorder[delimiterIndex] == rootValue) break;
        }
        //切割中序数组
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;
        //切割后序数组
        int leftPostorderBegin = postorderBegin;
        int leftPostorderEnd = postorderBegin + delimiterIndex - inorderBegin;
        int rightPostordreBegin = postorderBegin + delimiterIndex - inorderBegin;
        int rightPostordreEnd = postorderEnd - 1;
        root->left = travel(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = travel(inorder,rightInorderBegin, rightInorderEnd, postorder, rightPostordreBegin, rightPostordreEnd);
        return root;

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

下一题是用前序和中序构造二叉树，照猫画虎。

class Solution {
public:
    TreeNode* travel(vector<int>& preorder, vector<int>& inorder){
    if (preorder.size() == 0) return NULL;
    int rootvalue = preorder[0];//中间节点//
    TreeNode* root = new TreeNode(rootvalue);
    if (preorder.size() == 1) return root;//叶子结点返回根//
    int delimiterIndex;
    for(delimiterIndex = 0; delimiterIndex < inorder.size(); delimiterIndex++){
        if (inorder[delimiterIndex] == rootvalue) break;//找到切割点//
    }
//切中序数组
    vector<int> leftInorder(inorder.begin(), inorder.begin() + delimiterIndex);
    vector<int>  rightInorder(inorder.begin() + delimiterIndex + 1, inorder.end());
//切前序数组   
    vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + leftInorder.size());
    vector<int> rightPreorder(preorder.begin() + leftInorder.size(), preorder.end());
    root->left = travel(leftPreorder, leftInorder);
    root->right = travel(rightPreorder, rightInorder);
    return root;
    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
    if (preorder.size() == 0 || inorder.size() == 0) return NULL;
    return travel(preorder, inorder);
    }
};

下标法如下：

class Solution {
public:
    TreeNode* travel(vector<int>& preorder, int preorderBegin, int preorderEnd, vector<int>& inorder, int inorderBegin, int inorderEnd){
        if (preorderBegin == preorderEnd) return NULL;
        int rootValue = preorder[preorderBegin];
        TreeNode* root = new TreeNode(rootValue);
        if (preorderEnd - preorderBegin == 1) return root;
        //找中序切割点
        int delimiterIndex;
        for (delimiterIndex = 0; delimiterIndex < inorderEnd; delimiterIndex++){
            if (inorder[delimiterIndex] == rootValue) break;
        }
        //切割中序
        int leftinorderBegin = inorderBegin;
        int leftinorderEnd = delimiterIndex;
        int rightinorderBegin = delimiterIndex + 1;
        int rightinorderEnd = inorderEnd;
        //切割后序
        int leftpreorderBegin = preorderBegin + 1;
        int leftpreorderEnd = preorderBegin + 1 + delimiterIndex - inorderBegin;
        int rightpreorderBegin = preorderBegin + 1 + delimiterIndex - inorderBegin;
        int rightpreorderEnd = preorderEnd;
        root->left = travel(preorder, leftpreorderBegin, leftpreorderEnd, inorder, leftinorderBegin, leftinorderEnd);
        root->right = travel(preorder, rightpreorderBegin, rightpreorderEnd, inorder, rightinorderBegin, rightinorderEnd);
        return root;

    }
    TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
    if (preorder.size() == 0 || inorder.size() == 0) return NULL;
    return travel(preorder, 0, preorder.size(), inorder, 0, inorder.size());
    }
};

今天的最大收获是用中序和后序，中序和前序建立二叉树。再一次加深了对递归和回溯的掌握。