删除Haskell中一棵树上的所有叶子

Question

Hey guys i have a problem. I would like to delete all leaves of a tree. My init of a tree is data NBaum a = NBlatt a | NKnoten a [NBaum a] data NBaum a = NBlatt a | NKnoten a [NBaum a] . I have no idea how i can do this and which is the command that the Nblatt is empty. Maybe u guys can help me.

My function should take a NBaum as an input and the output is a NBaum too. entferneBlaetter :: NBaum a -> NBaum a

I tried already this code but it's wrong:

entferneBlaetter (NBlatt _) = NBlatt "test"
entferneBlaetter (NKnoten a b) = NKnoten a (entferneBlaetter_help b)

Answer 1

Here's a hint.

When dealing with NKnoten ab , we want to:

• scan all the trees in the b list:
  • if we find a leaf tree, we remove it from the list
  • if we find a node tree, we recursively remove the leaves from the subtrees of that node, and keep the result in the list.

A basic approach could be to write your entferneBlaetter_help recursively.

By the way, I think this exercise would best be realized using entferneBlaetter :: NBaum a -> Maybe (NBaum a) .

Answer 2

Some hints, apologies if you've gotten this far already:

Since, in Haskell, your trees are immutable, removing something from one means constructing a new tree without it. Hence the type entferneBlaetter :: NBaum a -> NBaum a .

All your leaves appear to be either NBlatt a nodes, or possibly NKnoten a [] nodes if that's allowed. But observe that, once you descend to a NKnoten node, it's too late; there's nothing you can return to construct a tree without one.

But you always scan the parent branch first, and the parent of a leaf node is always a NKnoten . So you might try to filter the list of daughter nodes. This might, however, leave you with a bare branch, NKnoten a [] . So, if you're allowed to change the type signature of entferneBlaetter, you could pass a Maybe NBaum up to the caller, and it could then check whether all the daughter nodes evaluated to Nothing , then pass back either the pruned branch or replace NKnoten a [] with NBlatt a .

As a bonus, if your tree consists of a single leaf node, you would then be able to prune it to Nothing . But if your interface is fixed, you can still define a helper function entferneBlaetter' :: NBaum -> Maybe NBaum .

Alternatively, you could make a second transformation pass that replaces all instances of NKnoten a [] with NBlatt a .

Answer 3

The problem isn't 100% specified in terms of what constitutes leaves and what should happen when the tree only has a single node. However, if we come up with a definition of "leaf" ...

isLeaf :: NBaum a -> Bool
isLeaf (NBlatt _)     = True
isLeaf (NKnoten _ []) = True
isLeaf _              = False

... we can give a recursive solution, recursing for each node in the list that is not a leaf, or removing it if it is.

entferneBlaetter :: NBaum a -> NBaum a
entferneBlaetter (NKnoten s xs) = NKnoten s [entferneBlaetter x | x <- xs, not $ isLeaf x]
entferneBlaetter x              = x