如何在Haskell的树中找到给定x的先前值？

Question

The task is to find a previous value to the given x in a tree in Haskell. IMPORTANT! Using Lists in any part is not allowed:

data SearchTree a = Leaf a | Node a (SearchTree a) (SearchTree a)

t1 = Node 5 ( Node 4 ( Leaf 1) 
                     ( Node 5 (Leaf 4) (Leaf 5))
            ) 
            ( Node 7 ( Node 6  ( Leaf 5 ) ( Leaf 7  )) 
                     ( Node 10 ( Leaf 9 ) ( Leaf 11 )) 
            )

previousVal :: Ord a => a -> (SearchTree a) -> a
previousVal x t = previousValHelp x t 

previousValHelp x (Leaf n) = error "Es gibt nichts kleineres"
previousValHelp x (Node n l r) = (max n (max (previousValHelp x l) (previousValHelp x r))) < x 

For example previousVal 9 t1 should give 7 out. I managed to make this code, but it's wrong... Does anyone here have an idea?

Thank you!

Answer 1

Haskell is about types. So it's best to start with the type signature of a function instead of the definition. And it also makes sense to let the type checker tell you what's wrong. It often leads to the solution.

So, I tried to compile your code. Compiler output can sometimes be a bit confusing, but that's something everyone has to go through. I cheated a little to make the output more useful by changing previousVal xt = previousValHelp xt to previousVal = previousValHelp (that is called eta reduction , but you may just ignore it if it's confusing for you).

Here is the output:

SearchTree.hs:11:15:
    Could not deduce (a ~ Bool)
    from the context (Ord a)
      bound by the type signature for
                 previousVal :: Ord a => a -> SearchTree a -> a
      at SearchTree.hs:10:16-48
      ‘a’ is a rigid type variable bound by
          the type signature for
            previousVal :: Ord a => a -> SearchTree a -> a
          at SearchTree.hs:10:16
    Expected type: a -> SearchTree a -> a
      Actual type: Bool -> SearchTree Bool -> Bool
    Relevant bindings include
      previousVal :: a -> SearchTree a -> a (bound at SearchTree.hs:11:1)
    In the expression: previousValHelp
    In an equation for ‘previousVal’: previousVal = previousValHelp

See how it tells you what type it expected of previousValHelp , but what it got instead:

Expected type: a -> SearchTree a -> a
  Actual type: Bool -> SearchTree Bool -> Bool

This type error shows also the logical error. The definition of previousValHelp is basically a foo < bar (just ignore the brackets and the recursion for a second). Mind that the above two lines do not show up in your initial version of the code... so try to figure out the meaning of the very first few lines of the whole compiler output as well.

Anyway, let's check now what type (<) has in ghci ( < is the infix version of (<) ):

Prelude> :t (<)
(<) :: Ord a => a -> a -> Bool

So it returns a value of type Bool (if given those two a arguments). Makes sense.

Remember how I told you to ignore the recursion and brackets for a second. Now let's figure out why not just the "return type" of your function is Bool, but the rest as well. Let's have a look:

previousValHelp x (Node n l r) =
  max n (max (previousValHelp x l) (previousValHelp x r)) < x

This might get a bit tricky. Since we already know that previousValHelp is a function that returns a Bool if given two parameters, we can deduce that the recursive calls (previousValHelp xl) and (previousValHelp xr) also return a Bool. That means we are running the inner function max (previousValHelp xl) (previousValHelp xr) with two Bool parameters and get back a Bool. See the type signature:

max :: Ord a => a -> a -> a

Now we have the outer function max n (max (...) (...)) as well... we already know the type of it's second parameter which is Bool (see above). Since the types must be consistent ( max True True works, but not max True 1 ) the first parameter n is assumed to be Bool as well. Aha. Check your definition of SearchTree... n is the type parameter of our SearchTree and as such we get SearchTree Bool ! Similarly, the parameters for (<) must be consistent as well. True < False works, while True < 1 does not. So the last step is to figure out the type of x. We already know that the left-side parameter of < is Bool... so x must also be Bool which is our first function parameter.

My guess is that you probably want to use (<) in a way that lets you choose what you want to do... instead of just returning the result. For that purpose, there are guards .

Again: for a language like haskell which has such a strong focus on types... it's really crucial to learn how to read type/compiler errors.

Answer 2

Note: in the below I assume that "previous value to x" means "the greatest value in the tree less than x" and that a SearchTree is a Binary Search Tree (ie. sorted).

Let's first have a look at why your code isn't working how you want it to.

One of the great things that Haskell gives us is expressive types, along with type inference, so let's see what type it thinks your previousValHelp function has:

Prelude> :t previousValHelp
previousValHelp :: Bool -> SearchTree Bool -> Bool

Ah! There's a problem! Our implementation of previousValHelp only works for SearchTree Bool ! That's not right, though, we want it to work for all a which fit the constraint Ord a . Try to work out why this is. (I'm not going to explain it here, but try working through the types to see why the SearchTree must be a SearchTree Bool .)

Let's start re-writing our previousVal function. We'll start with a type signature:

previousVal :: Ord a => a -> (SearchTree a) -> Maybe a

This says "assuming we can compare objects of some type a , we're going to define a function which takes an a , and a SearchTree containing a s, and returns to us either an a (wrapped in Just ), or Nothing ". (We're going to use a Maybe a instead of error , because then we can use the type system to make sure our program doesn't crash by forcing us to explicitly handle the Nothing result. It also makes the implementation of the recursive function much easier.)

Now, we know a SearchTree has two possible "shapes": either a Node or a Leaf . We'll have to implement a case for both of them.

previousVal x (Node v l r) = _
previousVal x (Leaf v) = _

Let's start with the Node case. There are two possible cases here: if the value at this Node is less than the value we're looking for, then we want to go down the right subtree ( r ), otherwise we want to go down the left subtree ( l ).

previousVal x (Node v l r) | v < x = previousVal x r
                           | otherwise = previousVal x l

For Leaf s the logic is even easier: if the value at the Leaf is less than the value we're looking for then we can return the value (because there's nothing else below us that could be "closer" to it than where we are currently). Otherwise, we just return Nothing .

previousVal x (Leaf v) | v < x = Just v
                       | otherwise = Nothing

Now, if you run the code we've written up until this point, you should find some cases where it works, and some where it fails. For example:

Prelude> previousVal 5 t1
Just 4
Prelude> previousVal 9 t1
Nothing

Why does it seem to work some times, but not others? Well, it turns out we've actually got a bug in our Node case above. See, when we go down the right-hand branch there the possibility that there won't be any values in that subtree which are less than x . In that case, the right hand tree will return a Nothing back to us. But if the right hand subtree returns a Nothing , then the Node we're currently at contains the largest value smaller than x , so we should return Just v instead. Instead of the Node case above we should have something like this:

previousVal x (Node v l r) | v < x = case previousVal x r of
                                       Nothing -> Just v
                                       value -> value
                           | otherwise = previousVal x l

Now it should work for 9, too:

Prelude> previousVal 9 t1
Just 7