标签: 二叉搜索树

LeetCode刷题【剑指 Offer 33】二叉搜索树的后序遍历序列

输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true,否则返回 false。假设输入的数组的任意两个数字都互不相同。

 

参考以下这颗二叉搜索树:

     5
    / \
   2   6
  / \
 1   3

示例 1:

输入: [1,6,3,2,5]
输出: false

示例 2:

输入: [1,3,2,6,5]
输出: true

 

提示:

  1. 数组长度 <= 1000
Related Topics
  • 二叉搜索树
  • 递归
  • 二叉树
  • 单调栈

  • 👍 541
  • 👎 0
  • 分段验证

    解题思路

    分段验证

    代码

    class Solution {
        public boolean verifyPostorder(int[] postorder) {
            return validate(postorder,0,postorder.length-1);
        }
    
    
        private boolean validate(int[] postorder, int left ,int right){
            //如果左指针大于等于右指针了,说明当前节点以及没有子节点了,自然是符合条件的】
            if (left>=right || left < 0 || right < 0) return true;
            //找到这段数组对应的根节点,根据后序遍历的特性,即为这段数组的最后一位
            int rootNum = postorder[right];
            //初始赋值
            int leftEnd = -1;
            int rightStart = -1;
            //开始遍历
            for (int i = left; i < right; i++) {
                if (postorder[i] < rootNum){
                    //如果这个值小于根节点的值,说明这个节点应该是在左子树中
                    leftEnd = i;
                }
                if (postorder[i] > rootNum && rightStart == -1){
                    //如果这个值大于根节点的值,说明这个节点应该是右子树上的
                    //且rightStart == -1 表示是第一次碰到的
                    rightStart = i;
                }
            }
            //此时如果符合条件的话,应该是 leftEnd 在 rightStart 的左边一位
            //或者  没有左子树:leftEnd == -1 且rightStart == left
            //或者  没有右子树:rightStart == -1 且leftEnd == right-1
            boolean validateResult = (leftEnd>-1 &&  rightStart> -1 && leftEnd+1== rightStart)
                    || ( leftEnd == -1 && rightStart == left )
                    || ( rightStart == -1 && leftEnd == right-1);
            //自身验证完了,还要对分割好了的子序列的有效性判断
            if (validateResult){
                return validate( postorder, left, leftEnd ) && validate( postorder, rightStart, right-1 );
            }
            return false;
        }
    }

    LeetCode刷题【剑指 Offer 68 – I】二叉搜索树的最近公共祖先

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

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

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

     

    示例 1:

    输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 8
    输出: 6 
    解释: 节点 2 和节点 8 的最近公共祖先是 6。
    

    示例 2:

    输入: root = [6,2,8,0,4,7,9,null,null,3,5], p = 2, q = 4
    输出: 2
    解释: 节点 2 和节点 4 的最近公共祖先是 2, 因为根据定义最近公共祖先节点可以为节点本身。

     

    说明:

    • 所有节点的值都是唯一的。
    • p、q 为不同节点且均存在于给定的二叉搜索树中。

    注意:本题与主站 235 题相同:https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-search-tree/

    Related Topics
    • 深度优先搜索
    • 二叉搜索树
    • 二叉树

  • 👍 239
  • 👎 0
  • 二叉搜索树特性

    1. 递归

    class Solution {
        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
            if (p.val > q.val){
                return lowestCommonAncestor(root,q,p);
            }
            if (root.val == p.val || root.val == q.val){
                return root;
            }
            if (root.val > p.val && root.val > q.val){
                return lowestCommonAncestor(root.left,p,q);
            }
            if (root.val < p.val && root.val < q.val){
                return lowestCommonAncestor(root.right,p,q);
            }
            return root;
        }
    }

    2. 指针

    class Solution {
        public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
            if (p.val > q.val){
                return lowestCommonAncestor(root,q,p);
            }
            TreeNode cur = root;
            while ((cur.val > p.val && cur.val >q.val) || (cur.val < p.val && cur.val <q.val)){
                if (cur.val > p.val && cur.val >q.val){
                    cur = cur.left;
                }
                if (cur.val < p.val && cur.val <q.val){
                    cur = cur.right;
                }
            }
            return cur;
        }
    }

    比较简单,不做过多分析了

    LeetCode刷题【700】二叉搜索树中的搜索

    给定二叉搜索树(BST)的根节点 root 和一个整数值 val

    你需要在 BST 中找到节点值等于 val 的节点。 返回以该节点为根的子树。 如果节点不存在,则返回 null 。

     

    示例 1:

    输入:root = [4,2,7,1,3], val = 2
    输出:[2,1,3]
    

    Example 2:

    输入:root = [4,2,7,1,3], val = 5
    输出:[]
    

     

    提示:

    • 数中节点数在 [1, 5000] 范围内
    • 1 <= Node.val <= 107
    • root 是二叉搜索树
    • 1 <= val <= 107
    Related Topics
  • 二叉搜索树
  • 二叉树

  • 👍 293
  • 👎 0
  • 根据二叉搜索树的左小右大的特性【递归&遍历树】

    递归

    class Solution {
        public TreeNode searchBST(TreeNode root, int val) {
            if (root == null){
                return null;
            }
            if (root.val == val){
                return root;
            }
            return root.val > val ? searchBST(root.left, val) : searchBST(root.right, val);
        }
    }

    应该没啥特殊的,二叉搜索树的特性

    左子节点  <   根节点   <  右子节点

    所以照着这个写就行了

    也可以改递归为遍历的写法,毕竟 递归和遍历循环是可以相互转化的

    遍历

    class Solution {
        public TreeNode searchBST(TreeNode root, int val) {
            while (root !=null){
                if (root.val == val) return root;
                root = root.val > val? root.left : root.right;
            }
            return root;
        }
    }

    LeetCode刷题【剑指 Offer 54】二叉搜索树的第k大节点

    给定一棵二叉搜索树,请找出其中第 k 大的节点的值。

     

    示例 1:

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

    示例 2:

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

     

    限制:

    • 1 ≤ k ≤ 二叉搜索树元素个数
    Related Topics
  • 深度优先搜索
  • 二叉搜索树
  • 二叉树

  • 👍 265
  • 👎 0
  • 中序遍历(倒着)

    二叉搜索树、既然顺着中序遍历是连续递增的序列,先遍历右子树、然后跟节点、最后左子树这样的顺序来遍历的话,就是一个连续递减的序列了。

    再找第K大的也就轻而易举了。

    代码

    class Solution {
        int theK;
        int theNum = -1;
        public int kthLargest(TreeNode root, int k) {
            theK = k;
            dfs(root);
            return theNum;
        }
    
        public void dfs(TreeNode node){
            if (null == node){
                return;
            }
            dfs(node.right);
            if (theK==0){
                return;
            }
            theK--;
            if (theK==0){
                theNum = node.val;
                return;
            }
            dfs(node.left);
        }
    }

    LeetCode刷题【426】将二叉搜索树转化为排序的双向链表

    将一个 二叉搜索树 就地转化为一个 已排序的双向循环链表

    对于双向循环列表,你可以将左右孩子指针作为双向循环链表的前驱和后继指针,第一个节点的前驱是最后一个节点,最后一个节点的后继是第一个节点。

    特别地,我们希望可以 就地 完成转换操作。当转化完成以后,树中节点的左指针需要指向前驱,树中节点的右指针需要指向后继。还需要返回链表中最小元素的指针。

     

    示例 1:

    输入:root = [4,2,5,1,3] 
    
    输出:[1,2,3,4,5]
    
    解释:下图显示了转化后的二叉搜索树,实线表示后继关系,虚线表示前驱关系。
    
    

    示例 2:

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

    示例 3:

    输入:root = []
    输出:[]
    解释:输入是空树,所以输出也是空链表。
    

    示例 4:

    输入:root = [1]
    输出:[1]
    

     

    提示:

    • -1000 <= Node.val <= 1000
    • Node.left.val < Node.val < Node.right.val
    • Node.val 的所有值都是独一无二的
    • 0 <= Number of Nodes <= 2000
    Related Topics
  • 深度优先搜索
  • 二叉搜索树
  • 链表
  • 二叉树
  • 双向链表

  • 👍 157
  • 👎 0
  • 二叉搜索树+中序遍历 = 前驱后继关系对应的递增序列

    一顿分析
    根据题意,要求重新对应前驱后继关系的链表,那么自然想到的就是二叉搜索树的中序遍历操作。

    那么我们就在中序遍历的过程中做文章

    1. 定义一个全局变量preNode,当前节点遍历结束的时候,把这个preNode指向到当前节点,这样到下一个节点的时候preNode指向的自然就是中序遍历的前一个节点,也就是当前节点的前驱节点
    2. 遍历到当前节点的时候,将preNoderight指向到当前节点,将当前节点的left指向到preNode,这样就算是完成了链表的基本链接操作
    3. 额外定义一个tmpNode,将他的right指向到我们在中序遍历过程中遇到的第一个节点,这样head那边的指针关系也关联上了
    4. 剩下最后的节点到指向到第一个节点的操作。在我们完成了上面所有操作之后preNode自然就是中序遍历的最后一个节点了,而tmpNoderight又指向了第一个节点,所以我们再在这时候将两者关联起来
    5. 结束收工

    代码

    class Solution {
    
        Node tmpNode = new Node();
        Node preNode;
    
        public Node treeToDoublyList(Node root) {
            if (null == root){
                return null;
            }
            dfs(root);
            preNode.right = tmpNode.right;
            tmpNode.right.left = preNode;
            return tmpNode.right;
        }
    
        public void dfs(Node node){
            if (null == node){
                return;
            }
            dfs(node.left);
            if (tmpNode.right == null){
                //把虚拟头结点连接到最小节点
                tmpNode.right = node;
            }
            if (preNode != null){
                //连起来
                preNode.right = node;
                node.left = preNode;
            }
            preNode = node;
            dfs(node.right);
        }
    
    }

    LeetCode刷题【230】二叉搜索树中第K小的元素

    给定一个二叉搜索树的根节点 root ,和一个整数 k ,请你设计一个算法查找其中第 k 个最小元素(从 1 开始计数)。

     

    示例 1:

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

    示例 2:

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

     

     

    提示:

    • 树中的节点数为 n
    • 1 <= k <= n <= 104
    • 0 <= Node.val <= 104

     

    进阶:如果二叉搜索树经常被修改(插入/删除操作)并且你需要频繁地查找第 k 小的值,你将如何优化算法?

    Related Topics
  • 深度优先搜索
  • 二叉搜索树
  • 二叉树

  • 👍 582
  • 👎 0
  • 【中序遍历 双解法】java中序遍历

    简单没啥好特别的,搜索树的特性,左小右大,依次遍历的话是从最小的读起的那么对应数组的第k-1位就是所求

    class Solution {
        List<Integer> list;
        public int kthSmallest(TreeNode root, int k) {
            list = new ArrayList<>();
            dfs(root);
            return list.get(k-1);
        }
    
        public void dfs(TreeNode node){
            if (node == null){
                return;
            }
            dfs(node.left);
            list.add(node.val);
            dfs(node.right);
        }
    }

    如上代码,既然我们知道了由小到大的特性,那么其实就不用遍历整个二叉树了,只要按个遍历了k个节点,将第k个节点返回即可

    class Solution {
        int num = 0;
        int k;
        public int kthSmallest(TreeNode root, int k) {
            this.k = k;
            return dfs(root);
    
        }
    
        public int dfs(TreeNode node){
            if (node == null){
                return -1;
            }
            int left = dfs(node.left);
            if (left >=0 ){
                return left;
            }
            if (++num == k){
                return node.val;
            }
            int right = dfs(node.right);
            if (right >=0 ){
                return right;
            }
            return -1;
        }
    }

    LeetCode刷题【653】两数之和 IV – 输入 BST

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

     

    示例 1:

    输入: root = [5,3,6,2,4,null,7], k = 9
    输出: true
    

    示例 2:

    输入: root = [5,3,6,2,4,null,7], k = 28
    输出: false
    

    示例 3:

    输入: root = [2,1,3], k = 4
    输出: true
    

    示例 4:

    输入: root = [2,1,3], k = 1
    输出: false
    

    示例 5:

    输入: root = [2,1,3], k = 3
    输出: true
    

     

    提示:

    • 二叉树的节点个数的范围是  [1, 104].
    • -104 <= Node.val <= 104
    • root 为二叉搜索树
    • -105 <= k <= 105
    Related Topics
  • 深度优先搜索
  • 广度优先搜索
  • 二叉搜索树
  • 哈希表
  • 双指针
  • 二叉树

  • 👍 273
  • 👎 0
  • 题解

    继续还是二叉搜索树,牢记特性,左小右大,中序遍历后是一个有序递增数组。

    那么直接一个中序遍历出来,这样题目就转换成在有个有序递增数组中寻找两个数的和能凑成k,是不是有点眼熟,对的,就是LeetCode刷题 【1】两数之和,先不管之前我们是怎么做的。

    那么,按照目前最直观的思路,从数组结尾开始的两个数字尝试相加,假设对应索引为index1,index2,如果这两个位置的值相加比目标值k,大,则尝试将前面一个索引往前移动一位,找一个更小的值相加看是否等于k,一直找到索引为0的位置。如果这两个最大的值相加的合比k小,说明不存在相加了能满足k的情况了。尝试过一轮之后,如果找不到合适的值,则将后一位的索引往前移动一位,继续这个过程。

    举例:【1,2,3,4,5,6,7,8】数组

    先用7+8尝试,如果大于则用6+8、5+8、4+8尝试,直到1+7尝试,如果没有合适的,则进行下一轮用6+7尝试,5+7、4+7依次尝试。

    好了,下面是代码:

    class Solution1 {
        List<Integer> list = new ArrayList<>();
        public boolean findTarget(TreeNode root, int k) {
            dfs(root);
            int index1 = list.size()-1;
            int index2 = index1-1;
    
            while (index2>=0){
                if (list.get(index1)+list.get(index2) < k){
                    return false;
                }
                while (index2 >= 0 && list.get(index1)+list.get(index2) >= k ){
                    if (list.get(index1)+list.get(index2) == k){
                        return true;
                    }
                    index2--;
                }
                index1--;
                index2=index1-1;
            }
            return false;
        }
    
        private void dfs(TreeNode node){
            if (null==node)return;
            dfs(node.left);
            list.add(node.val);
            dfs(node.right);
        }
    
    }

    而执行的结果告诉了我,问题应该不至于这样

    解答成功:
    执行耗时:1138 ms,击败了5.24% 的Java用户
    内存消耗:39.9 MB,击败了20.04% 的Java用户

    所以,回到上面的思路中间的过程看下,两个关键点“有序递增数组”,“在这个有序递增数组中寻找一个特定的值”,是不是很自然的就想到了此处应该可以用二分法来处理,此处后续省略。

    重新再看下整个思考的过程,就是一个求解a+b=k的过程,其中k预先已给出,a、b值在对二叉树遍历的时候能知道一个,就是当前节点的值。此时问题就变成了再二叉树的所有节点中找另一个值是否存在。此时问题就转换成了,在二叉树遍历过程中,已知了a,已知了k,再在二叉搜索树中搜索(k-a)这个值是否存在,可利用二叉树的左小右大的特性查找。

    代码:省略

    接下来再进一步,在a+b=k的求解过程中,查找b能否进一步优化呢?答案是可以的,遍历每个节点的时候把值存储到一个hash表中,这样查找b是否存在就可以从原来的搜索二叉树查找转换成hash查找,时间复杂度直接降为O(1)。

    class Solution {
    HashSet<Integer> hashSet = new HashSet<>();
    boolean result = false;
    public boolean findTarget(TreeNode root, int k) {
    dfs(root,k);
    return result;
    }

    private void dfs(TreeNode node, int k){
    if (null==node || result)return;
    dfs(node.left,k);
    if (!result){
    if (hashSet.contains(k-node.val)){
    result = true;
    }
    }
    hashSet.add(node.val);
    dfs(node.right,k);
    }

    }

    结果

    执行耗时:3 ms,击败了83.09% 的Java用户
    内存消耗:39.2 MB,击败了79.23% 的Java用户

    再看看我们之前第一题是怎么做的,LeetCode刷题 【1】两数之和,是不是回到了一样的解法上了。

    本题难度设定的是简单题,嗯,本质上就是在原来第一题两数之和的基础上嵌套了一个二叉树遍历。

    另外做这题的时候想到的一个点,二叉平衡搜索树的查找搜索过程,和二分法数组查找搜索,这两个算法,本质上是一样的。