Huffman encoding successive-merge function From SICP:


  Exercise 2.69.  The following
  procedure takes as its argument a list
  of symbol-frequency pairs (where no
  symbol appears in more than one pair)
  and generates a Huffman encoding tree
  according to the Huffman algorithm.

(define (generate-huffman-tree pairs)
    (successive-merge (make-leaf-set pairs)))

  
  Make-leaf-set is the procedure given
  above that transforms the list of
  pairs into an ordered set of leaves.
  Successive-merge is the procedure you
  must write, using make-code-tree to
  successively merge the smallest-weight
  elements of the set until there is
  only one element left, which is the
  desired Huffman tree. (This procedure
  is slightly tricky, but not really
  complicated. If you find yourself
  designing a complex procedure, then
  you are almost certainly doing
  something wrong. You can take
  significant advantage of the fact that
  we are using an ordered set
  representation.)


I wrote the following solution:

(define (generate-huffman-tree pairs)
  (successive-merge (make-leaf-set pairs)))

(define (successive-merge leaf-set)
  (define (iter result leaf-subset)
    (if (null? leaf-subset) 
        result 
        (let ((first-leaf (car leaf-subset)))
          (iter (make-code-tree first-leaf result) (cdr leaf-subset)))))
  (iter (make-code-tree (car leaf-set) (cadr leaf-set)) (cddr leaf-set)))


Is this a good answer?  Can it be improved?
It's been a while since I've done any Lisp/Scheme, but I'll make one style point and one algorithmic point.

Style point: it's usually more readable if you define structure projection functions with meaningful names rather than using car, cdr, etc.

Algorithmic point: the simplest way of doing this is to include some priority queue structure from the standard library.  Then you simply remove the two least items from the queue, create their combined Huffman tree, and reinsert them into the queue.  You're done when the queue contains only one item.