Haskell：将树变成地图

Question

基本上我想将 BST 树变成一个映射，其中节点是键，节点的出现次数是值。所以如果我输入这个：

toMap（第 13 页）

我会得到

> [(13,1)]

这是我目前所拥有的：

data Tree a = Empty | Node a (Tree a) (Tree a) deriving (Show)
leaf x = Node x Empty Empty

toMap' :: Int -> Tree a -> ([(a, Int)], Int)
toMap' a Empty = ([], a)
toMap' a (Node x xl xr) = ((x, a): xl' ++ xr', k)
                      where (xl', i) = toMap' (a+1) xl
                            (xr', k) = toMap' (i) xr

toMap :: Tree a -> [(a, Int)]
toMap = fst. toMap' 1

此程序返回一个地图，但值不正确。每个值都比前一个值大一（因此，如果有 3 个节点，则第三个节点的值将是 3）。我想我必须在每个新键上放置一个计数器，但我不确定如何。在此先感谢

Answer 1

假设您有一个函数 foldt 可以跨树折叠（以与您当前的应用程序无关的顺序），以及一些函数 insertIncr 插入或增加 Map a Int 中键的值，您可以应用一对一。

您将处理以下类型签名：

import Data.Map

foldt :: (a -> b -> b) -> b -> Tree a -> b
foldt f acc Empty = acc
foldt f acc (Node x l r) = acc'
    where accl = foldt f acc l
          accr = foldt f accl r
          acc' = f x accr

-- insert 1 if not present, increment if present
insertIncr :: Ord a => a -> Map a Int -> Map a Int
insertIncr = undefined

toMap' :: Ord a => Tree a -> Map a Int
toMap' = foldt insertIncr empty

insertIncr 函数可以使用例如Data.Map.insertWith。请注意，Ord 类型类对于将某些内容插入 Data.Map 是必需的。如果您更喜欢普通的[(a,Int)] 类型的映射，那么insertIncr 可以具有Eq a => a -> [(a,Int)] -> [(a,Int)] 类型。

编辑：将使用 adjustWithKey 的建议更改为 insertWith。

Answer 2

老实说，这是一个我只需通过组合分解来解决的案例。

data Tree a = Empty | Node a (Tree a) (Tree a) deriving (Show)

toMap :: Ord a => Tree a -> [(a, Int)]
toMap = countDups . toList

请注意，我必须在 a 上添加一个额外的约束。它至少需要Eq 才能完全解决，但Ord 允许渐近更好的解决方案。

这里的基本思想是将解决方案分解为多个部分，然后再弄清楚每个部分。所以，下一部分是toList。我不会假设顺序很重要，因此我会选择前缀顺序，因为它很容易变得既懒惰又简单。

toList :: Tree a -> [a]
toList Empty = []
toList (Node a l r) = a : toList l ++ toList r

好的，简单明了。继续计算重复项。让我们也把它分解成几部分。

countDups :: Ord a => [a] -> [(a, Int)]
countDups = map (\xs -> (head xs, length xs)) . group . sort

好吧，我可能利用Data.List 中的group 和sort 稍微作弊了。但另一方面，这正是group 旨在解决的问题。排序只是一个标准工具。

如果我导入了 Control.Arrow，我会将 lambda 替换为 (head &&& length)。但这只是一个标准的习语，并没有真正简化事情——它只是让它们的输入更简洁。

这种方法的主要思想是将问题分解成可以自己做一些有意义的事情的部分。然后将这些部分组合成一个完整的解决方案。有一种将Tree a 转换为[a] 的方法很方便。还不如有一个功能来做到这一点。一旦你这样做了，剩下的部分就是一个有用的逻辑，可用于处理列表。如果你把它分解，你会发现它是现有位列表功能的简单组合。

这通常是用任何编程语言解决问题的最佳方法之一 - 将大任务分解为小任务。在 Haskell 中这样做的好处在于，将较小的任务组合到整个过程中是一个非常简洁的过程。