二叉树的 preOrder 和 levelOrder

Question

I'm trying to implement preOrder (First, the root is considered, then recursively the left and then the right subtree) and levelOrder (The nodes are viewed in ascending depth from left to right.)

I have:

data BTree a = Nil | Node a (BTree a) (BTree a) deriving Show

preOrder :: BTree a -> [a]
preOrder Nil = []
preOrder (Node x lt rt) = x: ((preOrder lt) ++ (preOrder rt ))

it seems to work, but I'm struggeling with the levelOrder function, I just have:

levelOrder :: BTree a -> [a]
levelOrder Nil = []
levelOrder (Node x lt rt) =

I dont know what to do next to make it work.

Answer 1

Both algorithms require some sort of data structure to store nodes while they wait to be processed. preOrder can use the call stack to store the nodes implicitly. levelOrder , however, requires a first-in-first-out queue to be maintained explicitly.

Here's an outline of such a queue and the interface it provides.

data Queue a = ...

empty :: Queue a
isEmpty :: Queue a -> Bool
getNext :: Queue a -> (a, Queue a)
append :: Queue a -> a -> Queue a

-- Laws
-- * The empty queue is empty
-- isEmpty empty == True
-- * Appending to a queue produces a non-empty queue
-- isEmpty (append q x) == False
-- * A singleton queue yields the only value and an empty queue
-- getNext (append empty x) == (x, empty)
-- * getNext retrieves from one end, append adds to the other.
-- getNext (append q x) == 
--     let (y, rest) = getNext q 
--     in (y, append rest x)

(For simplicity, getNext is a partial function. You should use isEmpty to avoid trying to get a value from an empty queue. If you like, you can make getNext total by making the signature Queue a -> Maybe (a, Queue a) .)

---

Here is how levelOrder would make use of such a structure: start by putting the root of the tree in the queue, the repeatedly retrieve a value from the queue an process that node. The value is added to the return value, while the children are appended to the queue. Once the q is empty, you're done.

levelOrder :: BTree a -> [a]
levelOrder tree = go (append empty tree)
  where go q | isEmpty q = []
        go q = let (next, rest) = getNext q
               in case next of
                    Nil -> ...
                    (Node x left right) -> ...

I leave it to you to define the Queue data type, the functions that operate on that type, and to finish the definition of levelOrder using the queue.

(Once you've defined the data type, you may want to skip some of the interface functions in favor of direct pattern matching. For example, if you end up with a dedicated data constructor for an empty Queue , you don't really need isEmpty , or at least its definition is trivial.)