Question

I need to create a program that will reverse a list destructively. For example lets say..

scm> (define L (list 1 2 3 4))
scm> (reverse! L)
(4 3 2 1)
scm> L
(1)

Where L becomes the last element of the reversed list. I know I am supposed to use set-cdr! somehow but cannot figure out how to implement it.

Answer 1

Because this looks like homework, I can’t give you a straight answer. I’ll show you the general structure of the solution, so you can figure out the details and fill-in the blanks:

(define (reverse! lst)
  (let loop ((lst lst)
             (acc '()))
    (if (null? lst)
        acc
        (let ((tail <?1?>))
          (set-cdr! <?2?> <?3?>)
          (loop tail lst)))))

(define lst (list 1 2 3 4))
lst
> (1 2 3 4)

(reverse! lst)
> (4 3 2 1)

lst
> (1)

In the above code:

• The original list is traversed using a named let for simplicity, given that another parameter is needed
• A new acc parameter is defined, to serve as the accumulator for the reversed list
• When the recursion ends, the answer in the accumulator is returned

Now, for the recursive step:

• In <?1?> we need to obtain a reference to the rest of the list and save it, given that we’re going to modify it
• The key point lies in the line (set-cdr! <?2?> <?3?>). You’ll have to set the next element of the current list to the previously accumulated, reversed list
• Finally, the recursion proceeds with the new accumulated values

Notice that in the end, the lst reference got modified in-place and now is pointing to the last element of the list. If you need lst to point to the reversed list, then simply do this:

(define lst (list 1 2 3 4))
lst
> (1 2 3 4)

(set! lst (reverse! lst))
lst
> (4 3 2 1)

The procedure described reverses a list destructively and doesn’t create a new list (no cons operations are used.)