Scheme中列表的功能是什么？它需要能够处理嵌套列表。
因此，如果你做像(reverse '(a (b c d) e))这样的事情，你会得到(e (b c d) a)作为输出。
我该如何处理这个问题？我不只是在寻找答案，而是能帮助我学习的东西。
(define (reverse1 l)
(if (null? l)
nil
(append (reverse1 (cdr l)) (list (car l)))
)
)
说明：
规则： 1.如果list为空，则反向列表也为空 2.否则在列表的反向尾部后面添加列表的第一个元素
以这种方式看看这段代码：
reverse1是函数的名称，l是参数 如果list为空，则reverse也为空，否则使用（cdr l）调用reverse1函数，这是列表的尾部，并将其作为列表附加到第一个alement（car l）
在你的例子中（伪鳕鱼）：
1st iteration
l=>(a (bcd)e)
car l => a
cdr l => (bcd)e
list(car l) =>(a)
------------------
reverse( cdr l)"+"(a)
------------------
2nd iteration
l=>((bcd)e)
car l => (bcd)
cdr l =>e
list(car l)=>(bcd)
--------------------
reverse(cdr l)"+"((bcd))+(a)
-----------------------
3rd iteration
l=>e
car l=> e
cdr l => nil
list (car l) =>(e)
-------------------------
(e (bcd)a)
(define (my-reverse ls)
(define (my-reverse-2 ls acc)
(if (null? ls)
acc
(my-reverse-2 (cdr ls) (cons (car ls) acc))))
(my-reverse-2 ls '()))
这使用累加器变量来反转列表，将第一个元素从传入列表中取出并将其传递到累加器的前面。它隐藏了累加器获取功能并且只暴露了获取列表的函数，因此调用者不必传入空列表。这就是为什么我有我的反向2。
(my-reverse-2 '(a (b c d) e) '()); will call
(my-reverse-2 '((b c d) e) '(a)); which will call
(my-reverse-2 '(e) '((b c d) a)); which will call
(my-reverse-2 '() '(e (b c d) a)); which will return
'(e (b c d) a)
因为my-reverse-2中的最后一个函数调用是对my-reverse-2的调用，并且返回值是直接传递的（第一个调用的返回值是第二个调用的返回值，依此类推）my-reverse-2是尾部优化的，这意味着它不会耗尽堆栈的空间。因此，只要您愿意，就可以使用列表调用它。
如果您希望它应用于嵌套列表，请使用以下内容：
(define (deep-reverse ls)
(define (deep-reverse-2 ls acc)
(if (null? ls)
acc
(if (list? (car ls))
(deep-reverse-2 (cdr ls) (cons (deep-reverse (car ls)) acc))
(deep-reverse-2 (cdr ls) (cons (car ls) acc)))))
(deep-reverse-2 ls '()))
这会在将元素添加到列表之前检查该元素是否为列表，如果是，则首先将其反转。由于它调用自身来反转内部列表，因此它可以处理任意嵌套。
(deep-reverse '(a (b c d) e)) - > '(e (d c b) a)，它是反向字母顺序，尽管有一个嵌套列表。它评估如下：
(deep-reverse-2 '(a (b c d) e) '()); Which calls
(deep-reverse-2 '((b c d) e) '(a))
(deep-reverse-2 '(e) (cons (deep-reverse-2 '(b c d) '()) '(a)))
(deep-reverse-2 '(e) (cons (deep-reverse-2 '(c d) '(b)) '(a)))
(deep-reverse-2 '(e) (cons (deep-reverse-2 '(d) '(c b)) '(a)))
(deep-reverse-2 '(e) (cons '(d c b) '(a)))
(deep-reverse-2 '(e) '((d c b) a))
(deep-reverse-2 '() '(e (d c b) a))
'(e (d c b) a)
这是一种可以创建适用于嵌套列表的反向函数的方法：
(define (reverse-deep l)
(map (lambda (x) (if (list? x) (reverse-deep x) x)) (reverse l)))
伪代码中的说明： 首先按照通常的方式反转列表 然后对于反转列表中的每个元素： - 如果元素本身是一个列表：递归地应用该过程 - 否则：请勿触摸元件
您可以使用foldr简单地反转列表中的元素：
(foldr (lambda (a r) (append r (list a))) empty lst)
这是Racket中的反向功能，我更喜欢Scheme。它仅使用匹配模式匹配功能。
(define/match (rev l)
[('()) '()]
[((list a ... b)) (cons b (rev a))])
> (rev '(a (b c d) e))
'(e (b c d) a)
我的解决方案
(define (rvrs ls)
(if (null? ls)
empty
(append (rvrs (cdr ls)) (cons (car ls) empty))))
我使用了类似于插入排序的代码
(define deep-rev-list
(lambda (l)
(cond ((null? l) (quote ()))
((atom? (car l))
(swap-till-end (carl) (deep-rev-list (cdr l))))
(else
(swap-till-end (deep-rev-list (car l)) (deep-rev-list (cdr l)))))))
(define swap-till-end
(lambda (elm lst)
(cond ((null? lst) (cons elm '()))
(else
(cons (car lst) (swap-till-end elm (cdr lst)))))))
(define atom?
(lambda (x)
(and (not (null? x)) (not (pair? x)))))
我正在从记忆中复制它。可能存在一些错误。如果是这样的话，将纠正代码。但是使用的技术类似于THe Little Schemer :)中给出的嵌套列表的命令。我在DrRacket检查过它
（deep-rev-list'（（1 2）（3）（（4 5））））返回（（（5 4））（3）（2 1））