代码随想录第十天|二叉树（3）

目录

LeetCode 513. 找树左下角的值

LeetCode 112. 路径总和

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

LeetCode 654. 最大二叉树

LeetCode 617. 合并二叉树

LeetCode 700. 二叉搜索树中的搜索

LeetCode 98. 验证二叉搜索树

总结

---

LeetCode 513. 找树左下角的值

题目链接：LeetCode 513. 找树左下的值

思路：本题如果直接一点的话，可以用层序遍历，到最后一层的时候，输出最后一层的最左边的节点值就行了。

    int findBottomLeftValue(TreeNode* root) {
        queue<TreeNode*> que;
        if (!root) return root->val;
        que.push(root);
        int result;
        while (!que.empty()){
            int size = que.size();
            result = que.front()->val;
            for (int i = 0; i < size; i++){
                TreeNode* cur = que.front();
                que.pop();
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            }
        }
        return result;
    }

LeetCode 112. 路径总和

题目链接：LeetCode 112. 路径总和

思想：本题要计算从根节点到叶子结点路径上的总和，并且与目标总和相同。很明显就需要遍历二叉树，当达到叶子结点的时候，判断这条路径上的节点值总和是否为目标值，如果是，则跳出递归；如果不是，则回溯到叶子结点的上一个节点。由于回溯要返回到上一个节点，并且考虑到二叉树独特的遍历节点方式，所以回溯的时候一般采取父亲节点指向子节点的方式进行遍历、访问和取值。

代码如下：

    bool getTarget(TreeNode* cur, int sum){
        if (!cur->left && !cur->right && sum == 0){
            return true;
        }
        if (!cur->left && !cur->right) {
            return false;
        }
        if (cur->left){
            sum -= cur->left->val;
            if (getTarget(cur->left, sum)) return true;
            sum += cur->left->val;
        }
        if (cur->right){
            sum -= cur->right->val;
            if (getTarget(cur->right, sum)) return true;
            sum += cur->right->val;
        }
        return false;
    }

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

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

题目链接：LeetCode 106. 从中序与后序遍历序列构造二叉树、LeetCode 105. 从前序与中序遍历序列构造二叉树

思想：本题最主要的就是寻找前中后序之间的关系，需要注意的是，前序和后序构造不出来一个二叉树。首先是前序与中序之间的对应关系，前序的最前面的元素就是一棵树的根节点，通过这个根节点在中序序列找到这个节点，这个节点以左就是左子树，这个节点以右就是右子树，按照这个逻辑拆分中序序列。最后再对应拆分前序序列。再进行下一次递归，就行啦。而对应的中序与后序之间的关系就可以自己去发掘了。

代码如下：

    TreeNode* gouzao(vector<int>& preorder, vector<int>& inorder){
        if (preorder.size() == 0) return NULL;
        
        int rootValue = preorder[0];
        TreeNode* rootNode = new TreeNode(rootValue);

        if (preorder.size() == 1) return rootNode;

        int inIdex;
        for (inIdex = 0; inIdex < inorder.size(); inIdex++){
            if (rootValue == inorder[inIdex]) break;
        }

        vector<int> leftInorder(inorder.begin(), inorder.begin() + inIdex);
        vector<int> rightInorder(inorder.begin() + inIdex + 1, inorder.end());

        int preIndex = leftInorder.size();
        vector<int> leftPreorder(preorder.begin() + 1, preorder.begin() + preIndex + 1);
        vector<int> rightPreorder(preorder.begin() + preIndex + 1, preorder.end());

        rootNode->left = gouzao(leftPreorder, leftInorder);
        rootNode->right = gouzao(rightPreorder, rightInorder);

        return rootNode;
    }

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

LeetCode 654. 最大二叉树

题目链接：LeetCode 654. 最大二叉树

思想：本题跟上题的思想很像，反正就是找到数组里面的最大值，左边安排在左子树，右边安排在右子树就行了。

代码如下：

    TreeNode* gouzao(vector<int>& nums){
        if (nums.size() == 0) return NULL;

        int maxValue = 0;
        int index = 0;
        for (int i = 0; i < nums.size(); i++){
            if (maxValue <= nums[i]){
                maxValue = nums[i];
                index = i;
            }
        }
        TreeNode* rootNode = new TreeNode(maxValue);

        if (nums.size() == 1) return rootNode;

        vector<int> leftNums(nums.begin(), nums.begin() + index);
        vector<int> rightNums(nums.begin() + index + 1, nums.end());

        rootNode->left = gouzao(leftNums);
        rootNode->right = gouzao(rightNums);

        return rootNode;
    }

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

LeetCode 617. 合并二叉树

题目链接：LeetCode 617. 合并二叉树

思想：同时遍历两个树，只修改一个数的值，比如树1。如果两个树节点都有值，那么将树2节点的值加到树2身上；如果只有树1节点有值就返回树1节点，如果只有树2节点有值就返回树2节点。

代码如下：

    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;
    }

LeetCode 700. 二叉搜索树中的搜索

题目链接：LeetCode 700. 二叉搜索树中的搜索

思想：二叉搜索树就是左小右高。所以，当遍历到节点的时候，如果值小于节点值，则遍历左子树；反之，遍历右子树。

代码如下：

    TreeNode* searchBST(TreeNode* root, int val) {
        if (!root) return NULL;
        if (val == root->val) return root;
        else if (val > root->val) root = searchBST(root->right, val);
        else root = searchBST(root->left, val);
        return root;
    }

LeetCode 98. 验证二叉搜索树

题目链接：LeetCode 98. 验证二叉搜索树

思想：记住二叉搜索树的一个特性，即用中序遍历出来的数组满足升序。也就是说这题可以先用中序遍历出一个数组，然后检查这个数组是否满足升序即可。

代码如下：

    void judge(TreeNode* cur, vector<int>& nodes){
        if (!cur) return;
        judge(cur->left, nodes);
        nodes.push_back(cur->val);
        judge(cur->right, nodes);
    }

    bool isValidBST(TreeNode* root) {
        if(!root) return true;
        vector<int> nodes;
        judge(root, nodes);
        for (int i = 1; i < nodes.size(); i++){
            if (nodes[i] <= nodes[i - 1]) return false;
        }
        return true;
    }

总结

还是得熟练掌握遍历方法。