方案：以原始顺序重建列表的迭代过程？

Question

我的问题是：如何编写一个利用尾调用的过程，并且构造一个不按相反顺序的列表。 为了说明我的意思，下面是一个非常简单的迭代过程示例，它创建了一个列表的副本：

(define (copy-list ls)
    (define (iter cp-ls rest-ls)
      (if (null? rest-ls)
          cp-ls
          (iter (cons (car rest-ls) cp-ls) (cdr rest-ls))))
    (iter '() ls))

问题在于，由于元素consed 在一起的迭代顺序，返回的列表最终被颠倒了。是的，您可以通过在if 块中执行(reverse cp-list) 而不仅仅是cp-list 来轻松解决此问题，但问题在于reverse 是一个递归过程。使用此过程将抵消尾调用的优势，即堆栈大小随输入大小线性增长。

那么，基本上，如何编写像上面提到的那样以正确顺序返回列表的过程不使用任何类型的递归过程？

谢谢

Answer 1

请注意，您的 iter 过程几乎完全首先是如何实现 reverse - 不，这不是您在问题中提到的递归过程。

在 Racket 中检查过程的定义很简单：在没有定义的编辑窗口中键入reverse，右键单击它，然后选择“跳转到定义”。它将有一些额外的代码用于优化和错误处理，但算法的核心在letrec-values 部分，它与您的iter 过程相同。所以，如果我们已经拥有了：

(define (reverse ls)
  (let iter ((cp-ls '()) (rest-ls ls))
    (if (null? rest-ls)
        cp-ls
        (iter (cons (car rest-ls) cp-ls) (cdr rest-ls)))))

那么，copy-list 就是：

(define (copy-list ls)
  (reverse (reverse ls)))

顺便说一句，这并不是非常有用 - 如果你不改变列表，复制它是没有意义的。反向的反向只是原始的东西，不是吗？事实上，任何对不可变列表进行操作的copy-list 实现，无论出于何种意图和目的，都等效于身份过程：

(define (copy-list ls) ls)

Answer 2

您可以在下面使用延续传递样式，return -

(define (copy-list ls)
  (let loop ((ls ls) (return identity))
    (if (null? ls)
        (return null)
        (loop (cdr ls)
              (lambda (r) (return (cons (car ls) r)))))))

(copy-list '(1 2 3 4))
; '(1 2 3 4)

这是流程的样子 -

(copy-list '(1 2 3 4))
(loop '(1 2 3 4) identity)
(loop '(2 3 4) (lambda (r) (identity (cons 1 r))))
(loop '(3 4) (lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))))
(loop '(4) (lambda (r) ((lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))) (cons 3 r))))
(loop '() (lambda (r) ((lambda (r) ((lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))) (cons 3 r))) (cons 4 r))))
((lambda (r) ((lambda (r) ((lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))) (cons 3 r))) (cons 4 r))) null)
((lambda (r) ((lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))) (cons 3 r))) '(4))
((lambda (r) ((lambda (r) (identity (cons 1 r))) (cons 2 r))) '(3 4))
((lambda (r) (identity (cons 1 r))) '(2 3 4))
(identity '(1 2 3 4))
'(1 2 3 4)

Answer 3

(map (lambda(x) x) l)

将复制列表l，并且它不是递归编写的。

(let ((l '(1 2 3 4)))
  ((fold-right (lambda (e acc)
                 (lambda (x) (cons x (acc e))))
               (lambda (x) (list x))
               (cdr l))
   (car l)))

是另一种不递归复制列表的形式，但使用一个幺半群。

其他：

(let ((l '(1 2 3 4)))
  (car ((fold-right (lambda (e acc)
                      (lambda (x) (acc (append x (list e)))))
                    (lambda (x) (list x))
                    (cdr l))
        (list (car l)))))

其他：

(let ((l '(1 2 3 4)))
  (cdr ((fold-left (lambda (acc e)
                     (lambda (x) (cons x (acc e))))
                   (lambda (x) (list x))
                   l)
        'first)))

其他（Will 建议）：

(let ((l '(1 2 3 4)))
  ((fold-right (lambda (e acc)
                 (lambda (k) (k (acc (lambda (es) (cons e es))))))
               (lambda (z) (z (list))) l)
   (lambda (es) es)))

还有很多其他方法可以复制列表。一般来说，要制作副本，您需要直接或间接致电cons。

如 cmets 中所述，并非所有这些方式都使用迭代过程。