互联网经典算法之验证二叉搜索树

开发 前端 算法
本文主要介绍递归和深度优先搜索两种方法来解答此题,供大家参考,希望对大家有所帮助。

[[427951]]

本文转载自微信公众号「程序员小熊」,作者Dine 。转载本文请联系程序员小熊公众号。

前言

大家好,我是来自于华为的程序员小熊。今天给大家带来一道与二叉树相关的面试高频题,这道题在半年内被谷歌、字节、微软和亚马逊等大厂作为面试题,即力扣上的第98题-验证二叉搜索树。

本文主要介绍递归和深度优先搜索两种方法来解答此题,供大家参考,希望对大家有所帮助。

验证二叉搜索树

给你一个二叉树的根节点 root ,判断其是否是一个有效的二叉搜索树。

有效二叉搜索树定义如下:

节点的左子树只包含小于当前节点的数。

节点的右子树只包含大于当前节点的数。

所有左子树和右子树自身必须也是二叉搜索树。

示例 1

示例 2 及提示

二叉搜索树

题目已提示有效二叉搜索树的定义如下:

  • 节点的左子树只包含小于当前节点的数。
  • 节点的右子树只包含大于当前节点的数。
  • 所有左子树和右子树自身必须也是二叉搜索树。

举例

例 1

例1

例 2

例 3

判断二叉搜索树

针对上面的举例,根据二叉搜索树的判断方法,对上面的例子是否是二叉搜索树进行如下判断:

  • 例 1 不是 二叉搜索树。原因:根节点(值为 6)的左子树中有节点(值为 7)的数大于根节点的数。
  • 例 2 不是 二叉搜索树。原因:根节点(值为 6)的右子树中有节点(值为 3)的数小于根节点的数。
  • 例 3 不是 二叉搜索树。原因:根节点的左子树不是二叉搜索树,左子树的根节点的值 5 不仅小于左子节点的值 7 还大于右子节点的值 4,并且根节点的值 6 小于左子树中节点的值 7;根节点的右子树也不是二叉搜索树,右子树的根节点的值 8 不仅大于右子节点的值 3 还小于左子节点的值 9,并且根节点的值 6 大于右子树中节点的值 3。

解题思路

根据二叉搜索树的定义,判断一棵树是否是二叉搜索树,需要判断每个节点是否符合二叉树的性质,而且判断的依据又是一样的,因此可采用递归法去解答此题。

递归

上述提到的判断的依据(假设当前节点存在左右子节点)是指:

  1. 当前节点的值大于其左子节点的值;
  2. 当前节点的值小于其右子节点的值;
  3. 如果当前节点存在左右子树,则其左右子树上的节点还要满足:左子树上的节点值小于当前节点的值,右子树上的节点值大于当前节点的值;

根据以上的思路,可以通过设置上下界,来判断节点是否符合二叉搜索树的性质。

如果存在上下界,则判断节点是否在上下界内,如不在,则不是二叉搜索树;否则以该节点的值作为上界,对其左子树进行递归判断,以该节点的值作为下界,对其右子树进行递归判断。

注意

空树属于二叉搜索树。

Show me the Code

C

  1. bool isValidBST_Helper(struct TreeNode* root, double mindouble max) { 
  2.     /* 特殊判断 */ 
  3.     if (root == NULL) { 
  4.         return true
  5.     } 
  6.  
  7.     /* 当前节点不在上下界内,不是二叉搜索树 */ 
  8.     if (root->val <= min || root->val >= max) { 
  9.         return false
  10.     } 
  11.  
  12.     /* 判断左右子树是否是二叉搜索树 */ 
  13.     return isValidBST_Helper(root->leftmin, root->val) && isValidBST_Helper(root->right, root->val, max); 
  14.  
  15. bool isValidBST(struct TreeNode* root) { 
  16.     return isValidBST_Helper(root, LONG_MIN, LONG_MAX); 

C++

  1. bool isValidBST_Helper(TreeNode* root, double mindouble max) { 
  2.     if (root == nullptr) { 
  3.         return true
  4.     } 
  5.  
  6.     if (root->val <= min || root->val >= max) { 
  7.         return false
  8.     } 
  9.  
  10.     return isValidBST_Helper(root->leftmin, root->val) && isValidBST_Helper(root->right, root->val, max); 
  11.  
  12. bool isValidBST(TreeNode* root) { 
  13.     return isValidBST_Helper(root, LONG_MIN, LONG_MAX); 

Java

  1. boolean isValidBST_Helper(TreeNode root, double mindouble max) { 
  2.     if (root == null) { 
  3.         return true
  4.     } 
  5.  
  6.     if (root.val <= min || root.val >= max) { 
  7.         return false
  8.     } 
  9.  
  10.     return isValidBST_Helper(root.leftmin, root.val) && isValidBST_Helper(root.right, root.val, max); 
  11.  
  12. boolean isValidBST(TreeNode root) { 
  13.     return isValidBST_Helper(root, Long.MIN_VALUE, Long.MAX_VALUE); 

Python3

  1. def isValidBST(self, root: TreeNode) -> bool: 
  2.     def isValidBST_Helper(root, minright): 
  3.         if root is None: 
  4.             return True 
  5.          
  6.         if root.val <= min or root.val >= right
  7.             return False 
  8.  
  9.         return isValidBST_Helper(root.leftmin, root.val) and isValidBST_Helper(root.right, root.val, right
  10.  
  11.     return isValidBST_Helper(root, -float('inf'), float('inf'))  

Golang

  1. func isValidBST(root *TreeNode) bool { 
  2.   return isValidBST_Helper(root, math.MinInt64, math.MaxInt64) 
  3.  
  4. func isValidBST_Helper(root *TreeNode, minmax int) bool { 
  5.   if root == nil { 
  6.     return true 
  7.   } 
  8.  
  9.   if min >= root.Val || max <= root.Val { 
  10.     return false 
  11.   } 
  12.  
  13.   return isValidBST_Helper(root.Leftmin, root.Val) && isValidBST_Helper(root.Right, root.Val, max

复杂度分析

时间复杂度:O(n),其中 n 为二叉树节点的个数。

空间复杂度:O(n)。

深度优先搜索

根据二叉搜索树的性质,对其进行中序遍历,得到的数组一定是升序排列的。因此可以根据这个特性,判断一棵树是否是二叉搜索树。

如果采用中序遍历,将二叉树的所有节点的值存放在数组中,再去判断该数组是否是升序的,步骤有点繁琐。

由于判断数组是否是升序排列,只需要判断数组的后一个元素是否大于前一个元素即可,因此本题可以设置一个变量,用于保存中序遍历前一个节点的值,再判断当前节点的值是否大于该变量保存的值。

如果不大于,则代表该树不是二叉搜索树;否则继续遍历并判断。

Show me the Code

C++

  1. long pre = LONG_MIN; 
  2. bool isValidBST(TreeNode* root) { 
  3.     if (root == nullptr) { 
  4.         return true
  5.     } 
  6.  
  7.     if (!isValidBST(root->left)) { 
  8.         return false
  9.     } 
  10.  
  11.     if (root->val <= pre) { 
  12.         return false
  13.     } 
  14.  
  15.     pre = root->val;  
  16.     return isValidBST(root->right);       

Java

  1. long temp = Long.MIN_VALUE; 
  2. boolean isValidBST(TreeNode root) { 
  3.     if (root == null) { 
  4.         return true
  5.     } 
  6.  
  7.     if(!isValidBST(root.left)) { 
  8.         return false
  9.     } 
  10.  
  11.     if (root.val <= temp) { 
  12.         return false
  13.     }  
  14.  
  15.     temp = root.val; 
  16.     return isValidBST(root.right);         

复杂度分析

时间复杂度:O(n),其中 n 为二叉树节点的个数。

空间复杂度:O(n)。

 

责任编辑:武晓燕 来源: 程序员小熊
相关推荐

2022-01-11 10:01:25

二叉搜索树数量

2022-12-26 00:51:33

双向链表二叉搜索树

2013-07-15 16:35:55

二叉树迭代器

2021-12-07 06:55:17

二叉搜索树链表

2021-08-31 11:35:24

二叉搜索树迭代法公共祖先

2020-11-02 09:15:47

算法与数据结构

2021-09-29 10:19:00

算法平衡二叉树

2020-09-23 18:25:40

算法二叉树多叉树

2023-07-31 08:01:13

二叉搜索测试

2021-09-03 08:58:00

二叉搜索树节点

2021-09-02 11:31:28

二叉搜索树迭代法公共祖先

2023-02-13 08:02:08

哈希函数哈希表搜索树

2023-05-04 07:30:28

二叉搜索树BST

2020-04-27 07:05:58

二叉树左子树右子树

2021-03-22 08:23:29

LeetCode二叉树节点

2021-04-06 08:20:24

二叉搜索树数据结构算法

2021-08-26 11:31:11

二叉树数据结构算法

2024-01-17 07:36:50

二叉搜索联系簿

2021-09-07 11:01:41

二叉搜索树序数组

2021-09-28 06:28:51

二叉树公共祖先
点赞
收藏

51CTO技术栈公众号