LeetCode刷题 - - 树（六）二叉搜索树

最新推荐文章于 2022-08-03 11:39:18 发布

只不停

最新推荐文章于 2022-08-03 11:39:18 发布

阅读量496

点赞数

分类专栏： # 树

本文链接：https://blog.csdn.net/weixin_42082088/article/details/104448681

版权

树专栏收录该内容

6 篇文章 2 订阅

订阅专栏

文章目录

- 二叉搜索树

二叉搜索树

二叉搜索树，左子结点小于根结点小于右子节点。

递归怎么写？
1.总结规律，你知道你是在写一个递归方法，那么就得定义出这个递归方法是干什么的。
2.调用自己
3.跳出条件，跳出时的判断条件是什么以及当前条件下该返回什么。
需要注意的是，如果你的跳出条件有问题的话，递归很容易产生stackoverflow。

669. 修剪二叉搜索树

给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉搜索树，使得所有节点的值在[L, R]中 (R>=L) 。你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。

//BST 二叉查找树，根节点大于左结点，小于右结点
//对树进行遍历，去分析哪些值需要被剪掉，哪些被保留
class Solution {
    public TreeNode trimBST(TreeNode root, int L, int R) {
    if (root == null) return root;
    if (root.val > R) return trimBST(root.left, L, R); //比R大，向左修减
    if (root.val < L) return trimBST(root.right, L, R);//向右修剪
        //两边修剪，存在在【R,L】区间范围内
        root.left = trimBST(root.left, L, R);
        root.right = trimBST(root.right, L, R);
        return root;
    }
}

230. 二叉搜索树

给定一个二叉搜索树，编写一个函数 kthSmallest 来查找其中第 k 个最小的元素。
说明：
你可以假设 k 总是有效的，1 ≤ k ≤ 二叉搜索树元素个数。

示例 1：

输入: root = [3,1,4,null,2], k = 1
   3
  / \
 1   4
  \
   2
输出: 1

示例 2:

输入: root = [5,3,6,2,4,null,null,1], k = 3
       5
      / \
     3   6
    / \
   2   4
  /
 1
输出: 3

二叉搜索树的中序就是一个从小到大排序的序列，因此这道题可以通过中序遍历来做。

//第k个最小的元素
 //中序遍历 利用二叉搜索树的性质排列
 //从小到大排列
class Solution {
    public int kthSmallest(TreeNode root, int k) {
    Stack<TreeNode> stack = new Stack<>();
    while(true){
        while(root != null){
            stack.push(root);
            root = root.left;
        }
        root = stack.pop();
        if(--k == 0) return root.val;
        root = root.right;
    }
}
}

538. 把二叉搜索树转换成累加树

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

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

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

//此题是将大于自身结点的值都累计相加
 //相当于遍历整棵树，先遍历右-中-左
 //变形的中序遍历
class Solution {
    //定义一个变量来记录走过的结点的和
    public int sum = 0;
    public TreeNode convertBST(TreeNode root) {
        traver(root);
        return root;
    }
    //定义一个函数
    private void traver(TreeNode node){
       if(node == null) return;
       traver(node.right);
       sum += node.val;//将走过的结点累计相加
       node.val = sum;
       traver(node.left);
    }
}

公共祖先

235. 二叉搜索树的公共祖先

给定一个二叉搜索树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为：“对于有根树 T 的两个结点 p、q，最近公共祖先表示为一个结点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。”

例如，给定如下二叉搜索树: root = [6,2,8,0,4,7,9,null,null,3,5]
在这里插入图片描述

//因为该树为二叉搜索树，只要p和q在同一颗子树上就一直沿着这颗子树往下走
 //（这意味着p和q都同时大于或者小于当前指向的根结点）。
class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
    //找合适的位置，把它放进去
    TreeNode pointer = root;
    while(pointer != null){
      if(pointer.val > p.val && pointer.val > q.val){
        pointer = pointer.left;
    }else if(pointer.val < p.val && pointer.val < q.val){
        pointer = pointer.right;
    }else{
         return pointer;
    }
    }
        return pointer;
    }
}

236. 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

例如，给定如下二叉树: root = [3,5,1,6,2,0,8,null,null,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。因为根据定义最近公共祖先节点可以为节点本身。

class Solution {
    //功能：给定p和q,如果p和q存在，就返回最近的公共结点，
    //如果只有一个存在，那就返回那一个，如果都不存在，就返回空
   
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
      if(root == null || root == p || root == q)  return root;
       
       //我们在进行递归时，就默认递归已经帮我们实现了这个功能，我们只需要去告诉递归条件即可
      //找左边
      TreeNode left = lowestCommonAncestor(root.left, p ,q);
      TreeNode right = lowestCommonAncestor(root.right, p ,q);

      if(left == null)  return right;//都在右边
      if(right == null)  return left;//都在左边

      if(left != null && right != null) return root;//分散在两边

      return null;
    }
   
}

转换成二叉搜索树

108. 将有序数组转换成二叉搜索树

将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

给定有序数组: [-10,-3,0,5,9],

一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

//以中间结点为根节点，递归构建左右子数；
class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return BST(nums, 0 ,nums.length-1);
    }
    public TreeNode BST(int[] nums, int l, int r){
        if(l > r)  return null;
        
        int mid = (l+r)/2;
        TreeNode root = new TreeNode(nums[mid]);

        //向左递归
        root.left = BST(nums, l , mid-1);
        //向右递归
        root.right = BST(nums, mid+1 ,r);

        return root;

    }
}

109. 将有序链表转换成二叉搜索树

给定一个单链表，其中的元素按升序排序，将其转换为高度平衡的二叉搜索树。

本题中，一个高度平衡二叉树是指一个二叉树每个节点的左右两个子树的高度差的绝对值不超过 1。

示例:

给定的有序链表： [-10, -3, 0, 5, 9],

一个可能的答案是：[0, -3, 9, -10, null, 5], 它可以表示下面这个高度平衡二叉搜索树：

      0
     / \
   -3   9
   /   /
 -10  5

109题和108题不同的是，108题是将一个有序数组转换成二叉搜索，109题是将有序链表转换成二叉搜索树，有序数组的中间值很好找，而链表的中间值则需要通过快慢指针来找到

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
      if(head == null) return null;
      return buildBST(head, null);
    }
    
    public TreeNode buildBST(ListNode head, ListNode tail){
        if(head == null || head == tail)  return null;

        ListNode fast = head;
        ListNode slow = head;
        
        //注意这里是tail
        while(fast != tail && fast.next != tail){
            fast = fast.next.next;
            slow = slow.next;
        }
        TreeNode root = new TreeNode(slow.val);
        root.left = buildBST(head, slow);
        root.right = buildBST(slow.next, tail);
        return root;    
    }
}

653. 两数之和 IV – 输入BST

给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。

案例 1:

输入: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 9

输出: True

案例 2:

输入: 
    5
   / \
  3   6
 / \   \
2   4   7

Target = 28

输出: False

class Solution {
    public boolean findTarget(TreeNode root, int k) {
        List<Integer> list = new ArrayList<>();
        inOrder(root, list);
        int i = 0;
        int j = list.size()-1;
        while(i<j){
            int sum = list.get(i) + list.get(j);
            if(sum == k) return true;
            else if(sum < k) i++;
            else j--;
        }
        return false;

    }
    public void inOrder(TreeNode root, List<Integer> list){
         if(root == null) return;
         inOrder(root.left, list);
         list.add(root.val);
         inOrder(root.right, list);
    }
}

530. 二叉搜索树的绝对最小值之差

给定一个所有节点为非负值的二叉搜索树，求树中任意两节点的差的绝对值的最小值

输入:

   1
    \
     3
    /
   2

输出:
1

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

class Solution {
    
    public int getMinimumDifference(TreeNode root) {
    List<Integer> list = new ArrayList<>();
    inOrder(root, list);
    int minDiff = Integer.MAX_VALUE;
    //使其最小值无穷大，然后用其它值去更新最小值
    //排好序的二叉搜索树，差最小的两个点必然相邻；
    for(int i = 1; i < list.size(); i++){
        minDiff = Math.min(minDiff, list.get(i) - list.get(i-1));
    }
    return minDiff;
    }

    public void inOrder(TreeNode node, List<Integer> list){
        if(node == null) return;
        inOrder(node.left, list);
        list.add(node.val);
        inOrder(node.right, list);
    }
}

只不停

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
LeetCode刷题 - - 树（六）二叉搜索树

二叉搜索树，左子结点小于根结点小于右子节点。递归怎么写？1.总结规律，你知道你是在写一个递归方法，那么就得定义出这个递归方法是干什么的。2.调用自己3.跳出条件，跳出时的判断条件是什么以及当前条件下该返回什么。需要注意的是，如果你的跳出条件有问题的话，递归很容易产生stackoverflow。669. 修剪二叉搜索树给定一个二叉搜索树，同时给定最小边界L 和最大边界 R。通过修剪二叉...
复制链接

扫一扫