Leetcode 二叉树

112. Path Sum

再来看返回值，递归函数什么时候需要返回值？什么时候不需要返回值？这里总结如下三点：

• 如果需要搜索整棵二叉树且不用处理递归返回值，递归函数就不要返回值。（这种情况就是本文下半部分介绍的113.路径总和ii）
• 如果需要搜索整棵二叉树且需要处理递归返回值，递归函数就需要返回值。 （这种情况我们在236中介绍）
• 如果要搜索其中一条符合条件的路径，那么递归一定需要返回值，因为遇到符合条件的路径了就要及时返回。（本题的情况）                                                                         ----代码随想录

class Solution {
public:
    int findPath(TreeNode* root, int count){
        if(!root->left && !root->right && count == 0) return true;
        if(!root->left && !root->right) return false;

        if(root->left){
            if(findPath(root->left, count-root->left->val))
            return true;
        }if(root->right){
            if(findPath(root->right, count-root->right->val))
            return true;
        }

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

    }
};

 113. Path Sum II

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

需要注意的小点：

traversal默认root不为空，所以在main函数里要先写root为空的情况，并且targetsum的值是减掉root->val的值的 

106. Construct Binary Tree from Inorder and Postorder Traversal

重点思路，先找到root，在进行切割

class Solution {
public:
    TreeNode* traversal(vector<int>& inorder, vector<int>& postorder) {
        if(postorder.size() == 0) return NULL;

        int rootVal = postorder[postorder.size()-1];
        TreeNode* root = new TreeNode(rootVal);

        if(postorder.size() == 1) return root;

        int delimiterIndex;
        for(delimiterIndex=0; delimiterIndex<inorder.size();delimiterIndex++){
            if(inorder[delimiterIndex] == rootVal) 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 = traversal(leftInorder, leftPostorder);
        root->right = traversal(rightInorder, rightPostorder);

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

注意：

切割的区间（.begin()和.end()用法）

可以进行优化（没有写，下次可以写）不用每次切割区间都构造一个vector，直接记录index

105. Construct Binary Tree from Preorder and Inorder Traversal

优化写法

(有关区间的部分之后要在想想)

class Solution {
public:
    TreeNode* traversal(vector<int>& preorder, int preorderBegin, int preorderEnd, vector<int>& inorder, int inorderBegin, int inorderEnd){
        if(preorderBegin == preorderEnd) return NULL;

        int rootVal = preorder[preorderBegin];
        TreeNode* root = new TreeNode(rootVal);

        if(preorderEnd-preorderBegin == 1) return root;

        int delimiterIndex;
        for(delimiterIndex = inorderBegin; delimiterIndex<inorderEnd; delimiterIndex++){
            if(inorder[delimiterIndex] == rootVal)
            break;
        }

        int leftInorderBegin = inorderBegin;
        int leftInorderEnd = delimiterIndex;
        int rightInorderBegin = delimiterIndex + 1;
        int rightInorderEnd = inorderEnd;

        int leftPreorderBegin = preorderBegin+1;
        int leftPreorderEnd = preorderBegin+1+delimiterIndex - leftInorderBegin;
        int rightPreorderBegin = preorderBegin+1+delimiterIndex - leftInorderBegin;
        int rightPreorderEnd = preorderEnd;

        root->left = traversal(preorder, leftPreorderBegin, leftPreorderEnd, inorder, leftInorderBegin, leftInorderEnd);
        root->right = traversal(preorder, rightPreorderBegin, rightPreorderEnd, inorder, rightInorderBegin, rightInorderEnd);

        return root;

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

654. Maximum Binary Tree

整体思路对了，但有小问题

class Solution {
public:
    TreeNode* traversal(vector<int>& nums, int numsBegin, int numsEnd){
        if(numsBegin == numsEnd) return NULL;
        int delimiterIndex = numsBegin;
        for(int i=numsBegin; i<numsEnd; i++){
            if(nums[i] > nums[delimiterIndex]){
                delimiterIndex = i;
            }
        }

        TreeNode* root = new TreeNode(nums[delimiterIndex]);
        int leftBegin = numsBegin;
        int leftEnd = delimiterIndex;
        int rightBegin = delimiterIndex+1;
        int rightEnd = numsEnd;

        root->left = traversal(nums, leftBegin, leftEnd);
        root->right = traversal(nums, rightBegin, rightEnd);

        return root;
    }
    TreeNode* constructMaximumBinaryTree(vector<int>& nums) {
        if(nums.size() == 0) return NULL;
        return traversal(nums, 0, nums.size());
    }
};

617. Merge Two Binary Trees

class Solution {
public:
    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if(!root1) return root2;
        if(!root2) return root1;
        root1->val += root2->val;

        root1->left = mergeTrees(root1->left, root2->left);
        root1->right = mergeTrees(root1->right, root2->right);

        return root1;
    }
};

也可以用层序

700. Search in a Binary Search Tree

这里是二叉搜索树，是一个有序的树：左<中<右

1.递归

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        TreeNode* res = NULL;
        if(root == NULL ||root->val == val) return root;
        if(root->val > val) res = searchBST(root->left, val);
        if(root->val < val) res = searchBST(root->right, val);
        return res;
    }
};

2.迭代

class Solution {
public:
    TreeNode* searchBST(TreeNode* root, int val) {
        while(root){
            if(root->val > val){
                root = root->left;
            }else if(root->val < val){
                root = root->right;
            }else{
                return root;
            }        
        }

        return NULL;
    }
};