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

513.找树左下角的值 Find Bottom Left Tree Value

层序遍历(最简单明白的):

回顾一下层序遍历的写法.

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

递归法(需要理解一下):

有回溯的元素在里面

class Solution {  
public:  
    int maxDepth = INT_MIN;  
    int result;  
    void traversal(TreeNode* root, int depth) {  
        if (root->left == NULL && root->right == NULL) {  
            if (depth > maxDepth) {  
                maxDepth = depth;  
                result = root->val;  
            }  
            return;  
        }  
        if (root->left) {  
            traversal(root->left, depth + 1); // 隐藏着回溯  
        }  
        if (root->right) {  
            traversal(root->right, depth + 1); // 隐藏着回溯  
        }  
        return;  
    }  
    int findBottomLeftValue(TreeNode* root) {  
        traversal(root, 0);  
        return result;  
    }  
};

112. 路径总和 Path Sum

在回退的时候一开始遇到了问题. 没有考虑到

class Solution {  
private:  
    bool traversal(TreeNode* node, int count){  
        if (node->left == NULL && node->right == NULL && count == 0){  
            return true;  
        }  
        if (node->left == NULL && node->right == NULL){  
            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;  
    }  
public:  
    bool hasPathSum(TreeNode* root, int targetSum) {  
        if (root == NULL){  
            return false;  
        }  
        return traversal(root, targetSum - root->val);  
    }  
};

113.路径总和ii Path Sum II

跟112题差不多

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

106.从中序与后序遍历序列构造二叉树 Constract Binary Tree from Inorder and Postorder Traversal

看完讲解恍然大悟

class Solution {  
private:  
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder){  
        //1.后序数组为0,空节点  
        if (postorder.size() == 0) return NULL;  
        //2.后序数组最后一个元素为节点元素  
        int rootValue = postorder[postorder.size() - 1];  
        TreeNode* root = new TreeNode(rootValue);  
        if (postorder.size() == 1) return root;  
        //3.寻找中序位置作为切割点  
        int index = 0;  
        for (index = 0; index < postorder.size(); index++){  
            if (inorder[index] == rootValue) break;  
        }  
        //4.切割中序数组(左数组和右数组)  
        //中序左数组 = [0,index)        
        vector<int> leftInorder (inorder.begin(), inorder.begin() + index);  
        //中序右数组 = [index+1,end)        
        vector<int> rightInorder (inorder.begin() + index + 1, inorder.end());  
        //5.后序数组舍弃末尾元素.切割后序数组(左数组和右数组)  
        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());  
        //6.递归处理  
        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);  
    }  
};

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

class Solution {  
private:  
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder){  
        //1.后序数组为0,空节点  
        if (postorder.size() == 0) return NULL;  
        //2.后序数组最后一个元素为节点元素  
        int rootValue = postorder[postorder.size() - 1];  
        TreeNode* root = new TreeNode(rootValue);  
        if (postorder.size() == 1) return root;  
        //3.寻找中序位置作为切割点  
        int index = 0;  
        for (index = 0; index < postorder.size(); index++){  
            if (inorder[index] == rootValue) break;  
        }  
        //4.切割中序数组(左数组和右数组)  
        //中序左数组 = [0,index)        
        vector<int> leftInorder (inorder.begin(), inorder.begin() + index);  
        //中序右数组 = [index+1,end)        
        vector<int> rightInorder (inorder.begin() + index + 1, inorder.end());  
        //5.后序数组舍弃末尾元素.切割后序数组(左数组和右数组)  
        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());  
        // 以下为日志  

        //6.递归处理  
        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);  
    }  
};