Question

Imagine an arithmetic expression such as (+ 1 (* 2 (- 3 5))) being thought of as a tree-like structure with numbers at the leaves and operator symbols at the interior nodes like below:

     +
   /   \
  1     *
       /  \
      2    -
          /  \
         3    5

I have these functions already defined to access certain parts of the tree:

;; returns tree node
(define (operator lst)
  (cadr lst))

;; returns left tree
(define (left-op lst)
  (car lst))

;; returns right tree
(define (right-op lst)
  (cddr lst))

I am trying to write 3 functions preorder, inorder, and postorder that return a list of the tree traversed in the order they were encountered

I know how the tree traversal works from previous java programming but am having trouble coding this

ex for above:
(preorder '(+ 1 (* 2 (- 3 5)))) => (+ 1 * 2 - 3 5)

Answer 1

Your implementation of trees is not quite right, you need to represent a leaf (a number in the examples) as another tree with null left and right subtrees. Also, it’s useful having a make-tree “constructor”. Let’s go step-by-step – first, a correct abstraction for representing trees:

(define (make-tree value left right)
  (list left value right))

(define (operator tree)
  (cadr tree))

(define (left-op tree)
  (car tree))

(define (right-op tree)
  (caddr tree))

Now for the traversals. I’ll help you with the first one, preorder:

(define (preorder tree)
  (if (null? tree)
      '()
      (append (list (operator tree))
              (preorder (left-op tree))
              (preorder (right-op tree)))))

The tree in the question would look like this:

(define tree
  (make-tree '+
             (make-tree 1 '() '())
             (make-tree '*
                        (make-tree 2 '() '())
                        (make-tree '-
                                   (make-tree 3 '() '())
                                   (make-tree 5 '() '())))))

Use it like this:

(preorder tree)
> '(+ 1 * 2 - 3 5)

The other two traversals are very similar, just rearrange the three arguments for append in the correct order for each case – I’ll let that as an exercise for the reader.