Question

嗯，我真的不知道这是不是正确的标题，但我不知道如何称呼它。我的问题是关于我的作业，我现在工作了几个小时。主题是“功能数据结构”，我有点陷入困境，我不知道如何继续。

所以我需要用这个签名编写一个函数：

data Heap e t = Heap {
contains :: e -> t e -> Maybe Int
}

为了说明这一点，我得到了一些像这样的变量：

 x =   2
    3     4
  6   7     5

 x = Node 2 (Node 3 (Node 6 Empty Empty) (Node 7 Empty Empty)) (Node 4 Empty (Node 5 Empty Empty))

所以这是一些“树”的数据。

  contains heap 2 x  returns  Just 0
  contains heap 6 x  returns  Just 2
  contains heap 42 x  returns  Nothing

因此，如果x中存在“heap”后面的整数，则“contains”将返回“Just y”，其中y是树的“Level”。在我的例子中：2获得0级，3级和4级是1级，依此类推。这就是我的问题所在。我有一个函数，可以说整数是否在树中，但我不知道如何获得“Level”（我不知道如何调用它）。

我的功能如下：

contains = \e t -> case (e,t) of
   (_,Empty) -> Nothing
   (e , Node x t1 t2) ->
        if e == (head (heap2list heap (Node x t1 t2)))
            then Just 0
            else if ((contains heap e t1) == Just 0)
                     then Just 0
                     else contains heap e t2

如果整数在，则返回“Just 0”，否则返回“Nothing”。顺便说一句，我不允许使用自己编写的任何“帮助”函数。我可以使用的功能是：

empty :: t e                --Just returns an empty heap
insert :: e -> t e -> t e   --insert an element into a heap
findMin :: t e -> Maybe e   --find Min in a heap
deleteMin :: t e -> Maybe (t e)   -- delete the Min in a heap
merge :: t e -> t e -> t e        -- merges 2 heaps
list2heap :: Heap x t -> [x] -> t x   -- converts a list into a heap
heap2list :: Heap x t -> t x -> [x]   -- converts a heap into a list

给出了这些功能。 map，foldl，foldr ...也是允许的。我试图保持简短的问题，所以如果缺少任何信息我准备编辑它。

我会非常感谢任何帮助。请记住，这是一个家庭作业，我想要自己做，并在这里问这个问题是我最后的选择。

工作代码：

   contains = \e t -> case (e,t) of
(_,Empty) -> Nothing
(e , Node x t1 t2) ->
    if e == (head (heap2list heap (Node x t1 t2)))
        then Just 0
        else if (fmap (+1) (contains heap e t1))== Nothing
                    then (fmap (+1) (contains heap e t2))
                    else (fmap (+1) (contains heap e t1))

现在代码正在运行，所有“作业条件”都已完成，但在我看来它看起来很丑陋。我可以以某种方式翻新它吗？

Answer 1

问题是，规范目前尚未完成。该解决方案应该是广度优先还是左/右偏差深度优先算法？

仅使用Prelude功能的广度优先解决方案将是

-- Example data structure
data Tree e = Node e (Tree e) (Tree e) | Empty

-- Actual definition
contains e (Node c _ _)
 | e == c = Just 0
contains e (Node _ l r) = fmap (+ 1) $ case (contains e l, contains e r) of
                                            (Just a, Just b) -> Just $ min a b
                                            (Just a, _) -> Just a
                                            (_, b) -> b
contains _ Empty = Nothing

-- Given testdata:
x = Node 2 (Node 3 (Node 6 Empty Empty) (Node 7 Empty Empty)) (Node 4 Empty (Node 5 Empty Empty))

contains 2 x -- Just 0
contains 6 x -- Just 2
contains 42 x -- Nothing

-- unspecified example:
--          1
--      1       1
--    1   2        1
-- 2                  1
--                       2

x = Node 1 (Node 1 (Node 1 (Node 2 Empty Empty) Empty) (Node 2 Empty Empty)) (Node 1 Empty (Node 1 Empty (Node 1 Empty (Node 2 Empty Empty))))
contains 2 x -- Just 2 = breath-first
contains 2 x -- Just 3 = left biased depth-first
contains 2 x -- Just 4 = rigth biased depth-first

任何有偏见的深度优先应该很容易得出。

计算/获取分层数据的“级别”

1 个答案: