Question

So I was asked to make a Binary Tree in Haskell taking as input a list of Integers. Below is my code. My problem is that the last element of the list is not getting inserted in the Tree. For example [1,2,3,4] it only inserts to the tree until “3” and 4 is not inserted in the Tree.

    data ArbolBinario a = Node a (ArbolBinario a) (ArbolBinario a) | EmptyNode
deriving(Show)

    insert(x) EmptyNode= insert(tail x) (Node (head x) EmptyNode EmptyNode)

    insert(x) (Node e izq der)
     |x == [] = EmptyNode --I added this line to fix the Prelude.Head Empty List error, after I added this line the last element started to be ignored and not inserted in the tree
     |head x == e = (Node e izq der)
     |head x < e = (Node e (insert x izq) der)
     |head x > e = (Node e izq (insert x der))

Any ideas on whats going on here? Help is much appreciated

Answer 1

To solve this problem, I have used another function

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

insert :: Ord a => a -> Tree a -> Tree a
insert x EmptyNode = Node x EmptyNode EmptyNode
insert x (Node y left right)
    | x == y = (Node y left right)
    | x <  y = (Node y (insert x left) right)
    | x >  y = (Node y left (insert x right))

buildtree :: Ord a => [a] -> Tree a
buildtree []     = EmptyNode
buildtree (x:xs) = insert x (buildtree xs)

tree :: Ord a => [a] -> Tree a
tree xs = buildtree (reverse xs)

and to construct a binary tree, you need to call buildtree function. the problem is that you need to reverse the list first. So, tree will do the job.

*Main> insert 5 (insert 12 (insert 2 (insert 10 EmptyNode)))
Node 10 (Node 2 EmptyNode (Node 5 EmptyNode EmptyNode)) (Node 12 EmptyNode EmptyNode)

*Main> tree [10,2,12,5]
Node 10 (Node 2 EmptyNode (Node 5 EmptyNode EmptyNode)) (Node 12 EmptyNode EmptyNode)

*Main> buildtree [5,12,2,10]
Node 10 (Node 2 EmptyNode (Node 5 EmptyNode EmptyNode)) (Node 12 EmptyNode EmptyNode)

UPDATE

you can avoid using another function, this way:

insert2 :: Ord a => [a] -> Tree a -> Tree a
insert2 []     t = t
insert2 (x:xs) EmptyNode = insert2 xs (Node x EmptyNode EmptyNode)
insert2 (x:xs) (Node y left right)
            | x == y = insert2 xs (Node y left right)
            | x <  y = insert2 xs (Node y (insert2 [x] left) right)
            | x >  y = insert2 xs (Node y left (insert2 [x] right))

however, it is not as efficient as using foldl or the other way, the only good thing about it is using only one function to do everything, no reverse is required.

*Main> insert2 [10,2,12,5] EmptyNode
Node 10 (Node 2 EmptyNode (Node 5 EmptyNode EmptyNode)) (Node 12 EmptyNode EmptyNode)