折叠树函数

Question

我正在尝试为树编写折叠函数：

data BinaryTree a = Leaf
                  | Node (BinaryTree a) a (BinaryTree a)
                  deriving (Eq, Ord, Show)

foldTree :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTree _ base Leaf = base
foldTree fn base (Node left a right) = fn a (foldTree fn acc right)
         where acc = foldTree fn base left

这段代码几乎可以工作。然而并非总是如此。例如，它不会重建与原始树完全相同的树。

Answer 1

我在 Allen & Moronuki 的 Haskell Programming from first principle 的练习中苦苦挣扎后来到这里。这个问题听起来像是同一个练习，所以，对于它的价值，从一个初学者到另一个，这就是我想出的。

我看到了三种“折叠”（或变形）二叉树的方法。折叠序列时，有两种方法：向左折叠和向右折叠。一种方法是首先将给定函数应用于 (1) 列表的头部和 (2) 应用于列表尾部的递归调用的返回值。那是对的。

执行顺序折叠的另一种方法是首先在 (1) 应用于列表头部的给定函数的返回值和 (2) 列表尾部递归调用 fold。剩下一个折叠。

但是在二叉树中，每个值可以有两个“后续”值，而不是像列表中的一个。所以必须有两个递归调用折叠。因此，对传递函数的调用既可以在两个递归调用之外，也可以在两个递归调用内部，或者在它们之间。如果我将它们分别称为左、右和中心折叠，我会得到这些：

-- Fold Right for BinaryTree

foldTreer :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTreer f z Leaf = z
foldTreer f z (Node left a right) =
    f a (foldTreer f (foldTreer f z left) right)

-- Fold Left for Binary Tree

foldTreel :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTreel f z Leaf = z
foldTreel f z (Node left a right) =
    foldTreel f (foldTreel f (f a z) left) right

-- Fold Center for Binary Tree

foldTreec :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTreec f z Leaf = z
foldTreec f z (Node left a right) =
    foldTreec f (f a (foldTreec f z left)) right

我第一次看 Haskell 是在几周前，所以我可能对所有事情都完全错了，但在我看来就是这样。

Answer 2

GHC 擅长折叠东西。您的类型的结构包含足够的信息，以使您所需的按顺序遍历策略对机器来说是显而易见的。要调用魔法咒语，请说出 "deriving Foldable!"，GHC 会为您编写函数。

{-# LANGUAGE DeriveFoldable #-}
data BinaryTree a = Leaf
                  | Node (BinaryTree a) a (BinaryTree a)
                  deriving Foldable

现在我们有

foldTree = foldr

这里一个有趣的推论是，您可以通过改变类型的形状来改变遍历顺序。

---

当我们在这里时，请注意您的要求。你想实现一个函数，使用foldr，它把一棵树拆开，然后把它重新组合在一起，完全一样，相当于id。 这是不可能的。 foldr 提供对Foldable 结构元素的顺序 访问，擦除诸如元素在树中的精确位置之类的信息。充其量，您可以构建一个列表形状的树，元素沿着右脊椎出现：

toListShapedTree = foldr (Node Leaf) Leaf

你想要的是一个catamorphism：

cata :: (b -> a -> b -> b) -> b -> BinaryTree a -> b
cata node leaf Leaf = leaf
cata node leaf (Node l x r) = node (cata node leaf l) x (cata node leaf r)

注意node 参数的额外参数！本规范允许折叠函数访问Node 构造函数的参数。与Foldable 不同，结构的变质类型是特定于该结构的。通过将所有内容都视为列表，我们不会丢失信息。现在你可以写了：

cataId = cata Node Leaf

如果您坚决要为此使用foldr，则一种策略可能是随身携带位置信息。首先label each element with its position，然后在折叠中使用该数据重建树。对我来说似乎很辛苦。

Answer 3

我认为您正在寻找这种折叠：

foldTree :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTree _ base Leaf = base
foldTree fn base (Node left a right) = foldTree fn base' left
   where
   base'  = fn a base''
   base'' = foldTree fn base right

这大致是自动deriving Foldable 生成的内容。

上面是顺序折叠，先折叠左边部分，再折叠中间元素，再折叠右边。

一个等效但效率较低的变体是将树转换为具有 in-visit 的列表，然后在结果上应用 foldr fn base。可以在所有列表生成中“传播”foldr，恢复上面的代码。

Answer 4

感谢您的回答。我想我会保持原样，原因如下：

1. 类型签名在问题中给出，所以我认为这就是他们想要的。
2. 问题提到“任何遍历顺序都可以”。
3. 它可以工作，只是不是按顺序，例如。 foldTree (:) [] tree 将创建一个节点列表，但不是按顺序排列的。但是foldTree (+) 0 tree 会创建一个与顺序无关的总数。

Answer 5

我认为你需要在去右子树之前合并中间点：

foldTree :: (a -> b -> b) -> b -> BinaryTree a -> b
foldTree _ base Leaf = base
foldTree fn base (Node left a right) = foldTree fn middlePoint right
  where leftFold = foldTree fn base left
        middlePoint = fn a leftFold