刷题95—树（二）

142题—148题

知识点：

1. 二叉搜索树：一棵空树或者左子树小于根节点，右子树大于根节点的树
2. 先序遍历：根节点->左子树->右子树
3. 中序遍历：左子树->根节点->右子树
4. 后序遍历：左子树->右子树->根节点

142.合法二叉搜索树

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/legal-binary-search-tree-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

实现一个函数，检查一棵二叉树是否为二叉搜索树。

示例 1:
输入:
2
/
1 3
输出: true
示例 2:
输入:
5
/
1 4
  /
  3 6
输出: false
解释: 输入为: [5,1,4,null,null,3,6]。
  根节点的值为 5 ，但是其右子节点值为 4 。

题目分析

1. 二叉搜索树：一棵空树或者左子树小于根节点，右子树大于根节点的树；
2. 中序遍历：先遍历左子树再遍历根节点再遍历右子树；
3. 二叉搜索树使用中序遍历的结果是严格递增的，若不是，则不是二叉搜索树。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isValidBST = function(root) {
    let max = -Infinity;
    if(!root) return true;
    function check(root){
        if(!root) return true;
        if(check(root.left)){
            if(max < root.val){
                max = root.val;
                //console.log(max);
                return check(root.right);
            }
        }
        return false;
    }
    return check(root);
};

143.后继者

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/successor-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

设计一个算法，找出二叉搜索树中指定节点的“下一个”节点（也即中序后继）。

如果指定节点没有对应的“下一个”节点，则返回null。

示例 1:

输入: root = [2,1,3], p = 1

2
/
1 3

输出: 2
示例 2:

输入: root = [5,3,6,2,4,null,null,1], p = 6

5
/
3 6
/
2 4
/
1

输出: null

题目分析

1. 二叉搜索树：一棵空树或者左子树小于根节点，右子树大于根节点的树；
2. 中序遍历：先遍历左子树再遍历根节点再遍历右子树；
3. 对于每颗树的根节点，p大于根节点，解在右子树；
4. p小于根节点，解在左子树，若是不在，根节点就是解；
5. p等于根节点，解在右子树，最小节点就是解，若是没找到，返回null。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @return {TreeNode}
 */
var inorderSuccessor = function(root, p) {
    if(!root) return null;
    if(p.val > root.val) return inorderSuccessor(root.right,p);
    else if(p.val === root.val){
        let node = root.right;
        while(node && node.left){
            node = node.left;
        }
        return node;    
    }else{
        return inorderSuccessor(root.left,p) || root;
    }
};

　　

 

144.首个共同祖先

 

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/first-common-ancestor-lcci
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

设计并实现一个算法，找出二叉树中某两个节点的第一个共同祖先。不得将其他的节点存储在另外的数据结构中。注意：这不一定是二叉搜索树。

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,7,4]

3
/
5 1
/ /
6 2 0 8
/
7 4
示例 1:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 1
输入: 3
解释: 节点 5 和节点 1 的最近公共祖先是节点 3。
示例 2:
输入: root = [3,5,1,6,2,0,8,null,null,7,4], p = 5, q = 4
输出: 5
解释: 节点 5 和节点 4 的最近公共祖先是节点 5。因为根据定义最近公共祖先节点可以为节点本身。
说明:
所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

题目分析

1. 判断二叉树是否为空，若为空，return null；
2. 判断p节点或q节点是不是根节点，若是根节点，返回根节点；
3. 判断p节点或q节点是不是分别在根节点左右子树上，若是，返回根节点；
4. 判断p节点或q节点是不是在根节点的同一侧，是的话，返回left或right；

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    if(!root) return null;
    if(root.val == p.val || root.val == q.val) return root;
    let left = lowestCommonAncestor(root.left,p,q);
    let right = lowestCommonAncestor(root.right,p,q);
    if(left && right) return root;
    else return left || right;
};

145.二叉搜索树的最小绝对差

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

给你一棵所有节点为非负值的二叉搜索树，请你计算树中任意两节点的差的绝对值的最小值。

示例：

输入：

1

3
/
2

输出：
1

解释：
最小绝对差为 1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。
 

提示：

树中至少有 2 个节点。
本题与 783 https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes/ 相同

题目分析

1. 二叉搜索树：一棵空树或者左子树小于根节点，右子树大于根节点的树；
2. 中序遍历：先遍历左子树再遍历根节点再遍历右子树；
3. 把二叉搜索树通过中序遍历后存放在arr数组中；
4. 遍历arr数组，比较数组中两两的差值，找出最小的差值。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var getMinimumDifference = function(root) {
    if(!root) return null;
    let arr = [];
    let min;
    order(root,arr);
    for(let i=0; i<arr.length-1; i++){
        if(min){
            if(Math.abs(arr[i+1] - arr[i]) < min)
                min = Math.abs(arr[i+1] - arr[i]);
        }else{
            min = Math.abs(arr[i+1] - arr[i]);
        }
    }

    function order(root,arr){
        if(root){
            order(root.left,arr);
            arr.push(root.val)
            order(root.right,arr);
        } 
    }
    return min;
};

　　

146.二叉搜索树节点最小距离

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-distance-between-bst-nodes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

给定一个二叉搜索树的根节点 root，返回树中任意两节点的差的最小值。

示例：

输入: root = [4,2,6,1,3,null,null]
输出: 1
解释:
注意，root是树节点对象(TreeNode object)，而不是数组。

给定的树 [4,2,6,1,3,null,null] 可表示为下图:

4
/
2 6
/
1 3

最小的差值是 1, 它是节点1和节点2的差值, 也是节点3和节点2的差值。
 

注意：

二叉树的大小范围在 2 到 100。
二叉树总是有效的，每个节点的值都是整数，且不重复。
本题与 530：https://leetcode-cn.com/problems/minimum-absolute-difference-in-bst/ 相同

题目分析

与上一题相同

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var minDiffInBST = function(root) {
    if(!root) return null;
    let arr = [];
    order(root,arr);
    let min;
    for(let i=0; i<arr.length-1; i++){
        if(min){
            if(Math.abs(arr[i+1] - arr[i]) < min){
                min = Math.abs(arr[i+1] - arr[i]);
            }
        }else{
                min = Math.abs(arr[i+1] - arr[i]);
            }
    }
    
    function order(root,arr){
        if(root){
            order(root.left,arr);
            arr.push(root.val);
            order(root.right,arr);

        }
    }
    return min;
};

　　

147.把二叉搜索树转换为累加树

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/convert-bst-to-greater-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。

例如：

输入: 原始二叉搜索树:
5
/
2 13

输出: 转换为累加树:
18
/
20 13
 

注意：本题和 1038: https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree/ 相同

题目分析

1. 二叉搜索树：一棵空树或者左子树小于根节点，右子树大于根节点的树；
2. 因此，右子树不用改变，左子树需要加上右子树和根节点，根节点需要加上右子树；
3. 递归遍历右子树，把右子树的值加到根节点上，把改变后的根节点的值加到左子树上。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var convertBST = function(root) {
    if(!root) return null;
    let sum = 0;
    function add(root){
        if(root){
            add(root.right);
            sum += root.val;
            root.val = sum;
            add(root.left);
        }
    }
    add(root);
    return root;
};

148.从二叉搜索树到更大和树

题目链接

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search-tree-to-greater-sum-tree
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

题目描述

给出二叉 搜索 树的根节点，该二叉树的节点值各不相同，修改二叉树，使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

提醒一下，二叉搜索树满足下列约束条件：

节点的左子树仅包含键 小于 节点键的节点。
节点的右子树仅包含键 大于 节点键的节点。
左右子树也必须是二叉搜索树。
 

示例：

输入：[4,1,6,0,2,5,7,null,null,null,3,null,null,null,8]
输出：[30,36,21,36,35,26,15,null,null,null,33,null,null,null,8]
 

提示：

树中的节点数介于 1 和 100 之间。
每个节点的值介于 0 和 100 之间。
给定的树为二叉搜索树。
 

注意：该题目与 538: https://leetcode-cn.com/problems/convert-bst-to-greater-tree/  相同

题目分析

与上一题相同

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {TreeNode}
 */
var bstToGst = function(root) {
    if(!root) return null;
    let sum = 0;
    add(root);
    function add(root){
        if(root){
            add(root.right);
            sum += root.val;
            root.val = sum;
            add(root.left);
        }
        return root;
    }
    return root;
};