Reverse Monkey Puzzle sort (Haskell) - list

Question

I have a repeat in Haskell in Augest so I'm trying to practice my Haskell.
One of the questions is:
"A reverse monkey puzzle sort of a list is performed by storing the elements of the list into a binary tree and then traversing the tree so that the nodes of a subtree are visited in the order right child, parent and then left child. Write a reverse monkey puzzle sort in Haskell"
The question confuses me.
I know I have to write a function to go xr Node xl.
But does this have to output a list from the traversed tree? Or do I repopulate the binary tree with the list or what?
Also, would I start down in the farthest right element and go to that's parent then go left, or start at the very first root node at the top of the tree and go that way?
Also how would I go about writing it, Haskell is one of my weak points.
Appreciate any help with this!
Here is code I have
module Data.BTree where
data Tree a = Tip | Node a (Tree a) (Tree a) deriving (Show,Eq)
leaf x = Node x Tip Tip
t1 = Node 10 Tip Tip
t2 = Node 17 (Node 12 (Node 5 Tip(leaf 8)) (leaf 15))
(Node 115
(Node 32 (leaf 30) (Node 46 Tip (leaf 57)))
(leaf 163))
t3 = Node 172 (Node 143 (Node 92 (Node 76 (leaf 32) (leaf 45)) (Node 58 (leaf 39) (leaf 52))) (Node 107 (Node 92 (leaf 64) (leaf 35)) (Node 86 (leaf 69) (leaf 70))))
(Node 155 (Node 127 (leaf 83) (leaf 97)) (Node 138 (leaf 107) (leaf 91)))

Answer 1

You can write
data Tree a = Empty | Tree (Tree a) a (Tree a)
ins :: Ord a => Tree a -> a -> Tree a
ins Empty x = Tree Empty x Empty
ins (Tree l y r) x = if x < y then Tree (ins l x) y r else Tree l y (ins r x)
fromList :: Ord a => [a] -> Tree a
fromList = foldl ins Empty -- <<< FOLDABLE
toList :: Ord a => Tree a -> [a]
toList Empty = []
toList (Tree l x r) = (toList l) ++ [x] ++ (toList r) -- <<< MONOID
-- (change order if you wish)
sort :: Ord a => [a] -> [a]
sort = toList . fromList
to solve directly your problem.
In general is useful use more abstract structures like monoid, foldable, ... you can (must) read Learn You Haskell for Great Good!
:)
Example
*Main> sort [6, 3, 7, 8, 3, 6]
[3,3,6,6,7,8]
As commented (into code), one more general way to do it, is to define some useful structs into Tree: Foldable, Monoid and others.
Suppose we have that two structs implemented:
import Data.Foldable
import Data.Monoid
data Tree a = Empty | Tree (Tree a) a (Tree a) deriving Show
-- Shortcut
leaf :: Ord a => a -> Tree a
leaf x = Tree Empty x Empty
instance Foldable Tree where
foldMap f Empty = mempty
foldMap f (Tree l k r) = foldMap f l `mappend` f k `mappend` foldMap f r
-- WARNING: in that monoid only traverse result (ordered list) is invariant!
instance Ord a => Monoid (Tree a) where
mempty = Empty
mappend Empty tree = tree
mappend tree Empty = tree
mappend (Tree l x r) tree = ins (l `mappend` r `mappend` tree) x
where ins Empty x = leaf x
ins (Tree l y r) x = if x < y then Tree (ins l x) y r else Tree l y (ins r x)
that are usual in Haskell.
Now, your problem (define sort on lists using load/unload a tree) is simply:
sort :: Ord a => [a] -> [a]
sort = foldMap return . foldMap leaf
A more general way (struct) was detailed by #m0nhawk, #tel and #petr-pudlak in this question