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.

StackExchange Code Review Q#2046, answer score: 3