在Haskell中查找树是否为二叉搜索树


10
  type BSTree a = BinaryTree a

  data BinaryTree a = Null | Node (BinaryTree a) a (BinaryTree a)
                      deriving Show

  flattenTree :: BinaryTree a -> [a]
  flattenTree  tree = case tree of
      Null -> []
      Node left val right -> (flattenTree left) ++ [val] ++ (flattenTree right)

  isBSTree :: (Ord a) => BinaryTree a -> Bool
  isBSTree btree = case btree of
      Null -> False
      tree -> (flattenTree tree) == sort (flattenTree tree)

我想做的是编写一个函数来确定给定的树是否是二叉搜索树,我的方法是将所有值分组到一个列表中并导入Data.List,然后对列表进行排序以查找它们是否相等,但是有点复杂。我们可以不导入其他模块就能做到吗?


我不会flattenTree先定义。False如果节点违反了搜索属性,则可以尽早返回,而不必遍历以该节点为根的整个子树。
chepner,

@chepner的问题是sort,而不是flattenTree,这很懒。
尼斯,

是的,这是我在查看其他答案后想到的。
chepner

Answers:


13

这是一种无需展平树木的方法。

根据定义,

data BinaryTree a = Null | Node (BinaryTree a) a (BinaryTree a)
     deriving Show

可以看到,从左到右遍历树,忽略Node并加上括号,会给您Nulls和as 的交替序列。也就是说,在每两个值之间有一个Null

我的计划是检查每个子树是否满足合适的需求:我们可以在每个子树上完善需求Node,记住我们之间的值,然后在每个子树上进行测试Null。由于Null在每个有序的值对之间都有一个,因此我们将测试所有有序的(从左至右)对都不会减少。

有什么要求?它是树中值的宽松上下限。为了表达需求,包括最左边和最右边的需求,我们可以使用Bottom和Topelements 扩展任何顺序,如下所示:

data TopBot a = Bot | Val a | Top deriving (Show, Eq, Ord)

现在让我们检查给定的树是否满足顺序和在给定范围之间的要求。

ordBetween :: Ord a => TopBot a -> TopBot a -> BinaryTree a -> Bool
  -- tighten the demanded bounds, left and right of any Node
ordBetween lo hi (Node l x r) = ordBetween lo (Val x) l && ordBetween (Val x) hi r
  -- check that the demanded bounds are in order when we reach Null
ordBetween lo hi Null         = lo <= hi

二叉搜索树是树是为了和之间BotTop

isBSTree :: Ord a => BinaryTree a -> Bool
isBSTree = ordBetween Bot Top

计算每个子树中的实际极值,使其向外冒泡,会为您提供比您所需更多的信息,并且在左侧或右侧子树为空的边缘情况下比较麻烦。维护和检查需求,将需求向内推,则更加统一。


6

这是一个提示:做一个辅助功能

isBSTree' :: (Ord a) => BinaryTree a -> BSTResult a

在哪里BSTResult a定义为

data BSTResult a
   = NotBST             -- not a BST
   | EmptyBST           -- empty tree (hence a BST)
   | NonEmptyBST a a    -- nonempty BST with provided minimum and maximum

您应该能够递归进行,利用子树上的结果来驱动计算,尤其是最小和最大。

例如,如果您有tree = Node left 20 right,和isBSTree' left = NonEmptyBST 1 14isBSTree' right = NonEmptyBST 21 45isBSTree' tree则应为NonEmptyBST 1 45

在相同的情况下tree = Node left 24 right,我们应该有isBSTree' tree = NotBST

Bool然后将结果转换为微不足道的。


1
或为其定义明显的Monoid BSTResult a并对其进行折叠。:)(或即使它不是合法的Monoid ....)
尼斯

(但是,无论如何,这都是合法的)
内斯(Ness

3

是的,您不需要对列表进行排序。您可以检查每个元素是否小于或等于下一个元素。因为我们可以在O(n)中执行此操作,所以这效率更高,而评估排序后的列表完全需要O(n log n)

因此,我们可以使用以下方法检查此问题:

ordered :: Ord a => [a] -> Bool
ordered [] = True
ordered xa@(_:xs) = and (zipWith (<=) xa xs)

因此,我们可以检查二叉树是否是带有以下内容的二叉搜索树:

isBSTree :: Ord a => BinaryTree a -> Bool
isBSTree = ordered . flattenTree

我认为可以Null说它本身是一棵二叉搜索树,因为它是一棵空树。因此,这意味着对于每个节点(没有节点),左子树中的元素均小于或等于该节点中的值,而右子树中的元素均大于或等于该节点中的值。


1

我们可以像这样从左到右在树上继续前进:

isBSTtreeG :: Ord a => BinaryTree a -> Bool
isBSTtreeG t = gopher Nothing [Right t]
    where
    gopher  _   []                        =  True
    gopher  x   (Right Null:ts)           =  gopher x ts
    gopher  x   (Right (Node lt v rt):ts) =  gopher x (Right lt:Left v:Right rt:ts)
    gopher Nothing   (Left v:ts)          =  gopher (Just v) ts
    gopher (Just y)  (Left v:ts)          =  y <= v && gopher (Just v) ts

约翰·麦卡锡gopherJohn McCarthy)的启发。

可以通过继续传递来消除显式下推列表,

isBSTtreeC :: Ord a => BinaryTree a -> Bool
isBSTtreeC t = gopher Nothing t (const True)
    where
    gopher  x   Null           g  =  g x 
    gopher  x   (Node lt v rt) g  =  gopher x lt (\case
                                       Nothing -> gopher (Just v) rt g
                                       Just y  -> y <= v && gopher (Just v) rt g)

仅维护一个到目前为止最大的元素就足够了。

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.