代码随想录算法训练营第二十天 | 654.最大二叉树 、617.合并二叉树、700.二叉搜索树中的搜索、98.验证二叉搜索树

先复习下day18的内容

112. 路径总和

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool traversal(TreeNode* node, int restCount) {
        if(!node->left && !node->right && restCount==0) {
            return true;
        }
        if(!node->left && !node->right) {
            return false;
        }

        // 左右还有剩节点
        if(node->left) {
            restCount -= node->left->val;
            if(traversal(node->left, restCount)) {return true;}
            restCount += node->left->val;
        }
        if(node->right) {
            restCount -= node->right->val;
            if(traversal(node->right, restCount)) {return true;}
            restCount += node->right->val;
        }
        return false;
    }

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

113. 路径总和 II

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void traversal(TreeNode* node, int restSum, vector<int>& cur, vector<vector<int>>& ans) {
        if(!node->left && !node->right && restSum==0) {
            ans.push_back(cur);
            return;
        }
        if(!node->left && !node->right) {
            return;
        }
        if(node->left) {
            restSum -= node->left->val;
            cur.push_back(node->left->val);
            traversal(node->left, restSum, cur, ans);
            cur.pop_back();
            restSum += node->left->val;
        }
        if(node->right) {
            restSum -= node->right->val;
            cur.push_back(node->right->val);
            traversal(node->right, restSum, cur, ans);
            cur.pop_back();
            restSum += node->right->val;
        }

    }

    vector<vector<int>> pathSum(TreeNode* root, int targetSum) {
        if(root==nullptr) {
            return {};
        }
        vector<int> cur;
        vector<vector<int>> ans;
        cur.push_back(root->val);
        traversal(root, targetSum-root->val, cur, ans);
        return ans;
    }
};

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    // 前序：中左右；中序：左右中
    TreeNode* traversal(vector<int>& preorder, int preorderBegin, int preorderEnd,
        vector<int>& inorder, int inorderBegin, int inorderEnd) {
            if(preorderBegin==preorderEnd) {
                return nullptr;
            }
            int rootValue = preorder[preorderBegin];
            TreeNode* root = new TreeNode(rootValue);
            if(preorderEnd-preorderBegin==1) {
                return root;   
            }

            // 分割点
            int breakIndex;
            for(breakIndex=inorderBegin; breakIndex<inorderEnd; breakIndex++) {
                if(inorder[breakIndex]==rootValue) {
                    break;
                }
            }
            // 中序
            int leftInBegin = inorderBegin;
            int leftInEnd = breakIndex;
            int rightInBegin = breakIndex+1;
            int rightInEnd = inorderEnd;

            // 前序
            int leftPreBegin = preorderBegin+1;
            int leftPreEnd = leftPreBegin + (leftInEnd-leftInBegin);
            int rightPreBegin = leftPreEnd; 
            int rightPreEnd = preorderEnd;

            root->left = traversal(preorder, leftPreBegin, leftPreEnd, inorder, leftInBegin, leftInEnd);
            root->right = traversal(preorder, rightPreBegin, rightPreEnd, inorder, rightInBegin, rightInEnd);
            return root;
        }

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

    }
};

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

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, int inBegin, int inEnd,
        vector<int>& postorder, int postBegin, int postEnd) {
            if(postBegin==postEnd) {
                return nullptr;
            }
            int rootValue = postorder[postEnd-1];
            TreeNode* root = new TreeNode(rootValue);
            if(postEnd - postBegin == 1) {
                return root;
            }
            int breakIndex;
            for(breakIndex=inBegin; breakIndex<inEnd; breakIndex++) {
                if(inorder[breakIndex]==rootValue) {
                    break;
                }
            }
            int leftInBegin = inBegin;
            int leftInEnd = breakIndex;
            int rightInBegin = breakIndex+1;
            int rightInEnd = inEnd;

            int leftPostBegin = postBegin;
            int leftPostEnd = leftPostBegin + (leftInEnd-leftInBegin);
            int rightPostBegin = leftPostEnd;
            int rightPostEnd = postEnd-1;

            root->left = traversal(inorder, leftInBegin, leftInEnd, postorder, 
                leftPostBegin, leftPostEnd);
            root->right = traversal(inorder, rightInBegin, rightInEnd, postorder,
                rightPostBegin, rightPostEnd);
            return root;
        }

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

 654. 最大二叉树

想法：根据切分点，进行递归

阅读后想法：前序遍历-中左右

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int begin, int end) {
        if(begin>=end) {
            return nullptr;
        }
        int maxIndex = begin;
        for(int i=begin; i<end; ++i) {
            maxIndex = nums[maxIndex]>nums[i]?maxIndex:i;
        }
        TreeNode* root = new TreeNode(nums[maxIndex]);
        root->left = traversal(nums, begin, maxIndex);
        root->right = traversal(nums, maxIndex+1, end);
        return root;
    }

    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        return traversal(nums, 0, nums.size());

    }
};

617. 合并二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(root1==nullptr) { return root2; }
        if(root2==nullptr) { return root1; }
        
        TreeNode* root = new TreeNode(root1->val+root2->val);
        root->left = mergeTrees(root1->left, root2->left);
        root->right = mergeTrees(root1->right, root2->right);
        return root;
    }
};

700. 二叉搜索树中的搜索

想法：先检查节点；再判断左右，进行递归

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        if(root==nullptr) {
            return nullptr;
        }
        if(root->val==val) {
            return root;
        } else if(root->val>val) {
            return searchBST(root->left, val);
        }else {
            return searchBST(root->right, val);
        }
        return nullptr;
    }
};

98. 验证二叉搜索树

想法：通过中序遍历，比较节点，按顺序

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    long long maxValue = LONG_MIN;
    // TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) {
            return true;
        }
        bool leftinfo = isValidBST(root->left);
        if(root->val>maxValue) {
            maxValue = root->val;
        }else {
            return false;
        }

        bool rightinfo = isValidBST(root->right);
        return leftinfo&&rightinfo;
    }
};

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:

    TreeNode* pre = nullptr;
    bool isValidBST(TreeNode* root) {
        if(root==nullptr) {
            return true;
        }
        bool leftinfo = isValidBST(root->left);
        
        if(pre!=nullptr && pre->val>=root->val) { return false; }
        pre = root;

        bool rightinfo = isValidBST(root->right);
        return leftinfo&&rightinfo;
    }
};

总结：
创建二叉树：前序遍历 - 中左右

搜索二叉树：中序遍历