Day16 路径总和&&根据遍历构造二叉树

最新推荐文章于 2024-10-02 22:45:05 发布

Pepsi_I

最新推荐文章于 2024-10-02 22:45:05 发布

阅读量40

点赞数

分类专栏：算法学习文章标签：算法

本文链接：https://blog.csdn.net/Pepsi_I/article/details/134107235

版权

算法学习专栏收录该内容

31 篇文章 0 订阅

订阅专栏

LeetCode 112. 路径总和

回溯递归1.0

class Solution {
public:
    int res = 1001;
    bool traversal(TreeNode* root, int target) {
        if (!root->left && !root->right && target == 0) {
            return true;
        }
        if (!root->left && !root->right) {
            return false;
        }
        if (root->left) {
            if (traversal(root->left, target - root->left->val)) return true;
        }
        if (root->right) {
            if (traversal(root->right, target - root->right->val)) return true;
        }
        return false;
    }

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

回溯递归2.0

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if (!root) {
            return false;
        }
        if (!root->left && !root->right && targetSum - root->val == 0) {
            return true;
        }
        return hasPathSum(root->left, targetSum - root->val) || hasPathSum(root->right, targetSum - root->val);
    }
};

迭代（前序遍历）

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

LeetCode 113. 路径总和 II

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

    }
    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if (!root) {
            return res;
        }
        path.push_back(root->val);
        traversal(root, targetSum - root->val);
        return res;
    }
};

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

version1

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if (postorder.size() == 0) {
            return nullptr;
        }
        int splitValue = postorder[postorder.size() - 1];
        TreeNode* root = new TreeNode(splitValue);
        if (postorder.size() == 1) {
            return root;
        }
        int delimiter;
        for (delimiter = 0; delimiter < inorder.size(); delimiter++) {
            if (inorder[delimiter] == splitValue){
                break;
            }
        }
        vector<int> leftInorder(inorder.begin(), inorder.begin() +delimiter);
        vector<int> rightInorder(inorder.begin() + delimiter + 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 = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);
        return root;
    }


    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, postorder);

    }
};

version2

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, int inorderBegin, int inorderEnd, vector<int>& postorder, int postorderBegin, int postorderEnd){
        if (postorderBegin == postorderEnd) {
            return nullptr;
        }
        int splitValue = postorder[postorderEnd - 1];
        TreeNode* root = new TreeNode(splitValue);
        if (postorderEnd - postorderBegin == 1) {
            return root; 
        }
        int delimiter;
        for (delimiter = inorderBegin; delimiter < inorderEnd;delimiter++){
            if (inorder[delimiter] == splitValue) {
                break;
            }
        }
        //左中
        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiter;
        //右中
        int rightInorderBegin =  delimiter + 1;
        int rightInorderEnd = inorderEnd;
        //左后
        int leftPostorderBegin = postorderBegin;
        int leftPostorderEnd = postorderBegin + (leftInorderEnd - leftInorderBegin);
        //右后
        int rightPostorderBegin = leftPostorderEnd;
        int rightPostorderEnd = postorderEnd - 1;
        root->left = traversal(inorder, leftInorderBegin, leftInorderEnd, postorder, leftPostorderBegin, leftPostorderEnd);
        root->right = traversal(inorder, rightInorderBegin, rightInorderEnd, postorder, rightPostorderBegin, rightPostorderEnd);
        return root;
    }

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        return traversal(inorder, 0, inorder.size(), postorder, 0, postorder.size());
    }
};