Lisp 创建列表的自定义反转

我正试图在Lisp中创建一个自定义的列表反转。我对Lisp编程相当陌生，仍然在为语法而挣扎。这是到目前为止我的代码

(defun new-union(l1 l2)
    (setq l (union l1 l2))
       (let (res) 
         (loop for x in l
           do(setq res (cons (car l) res))
           do(setq l (cdr l)))))

在这里，我得到两个列表，并形成联合列表

l

。然后，为了反转列表

l

，我正在访问元素，将其附加到一个新列表

res

。然后使用

cons

、

car

和

cdr

更新列表。 然而，我得到了一个奇怪的输出。有人能告诉我哪里出了问题吗

我知道同一个函数有一个内置函数，名为

nreverse

，但我想尝试一下Lisp如何解释列表中的数据

例如，在末尾打印

res

(new-union '(a b c) '(d e f))

上面调用的输出给我

(L A A A A A A A X X)

---

我想我在做循环错误

好的……我想你应该把两个列表合并在一起，删除重复项，然后将它们颠倒过来

您最大的问题是使用循环而不是递归。LISP天生就是使用递归进行列表处理的。这更自然

下面是一个非常简单的示例，说明了如何做到这一点：

(defvar l1 '(a b c))      ;first list
(defvar l2 '(d e f))      ;second list

(defun my-reverse (a b)   ;a and b are lists
  "combines a and b into lst, removes duplicates, and reverses using recursion"
  (let ((lst (remove-duplicates (append a b))))   
    (if (> (length lst) 0)
        (append (last lst) (my-reverse nil (butlast lst)))
        nil)))

使用SBCL在SLIME中编译的示例运行

; compilation finished in 0:00:00.010                                                                                                                                    
CL-USER> l1 ;; verify l1 variable
(A B C)                                                                                                                                                                  
CL-USER> l2 ;; verify l2 variable
(D E F)                                                                                                                                                                  
CL-USER> (append l1 l2) ;; append l1 and l2
(A B C D E F)                                                                                                                                                            
CL-USER> (my-reverse l1 l2) ;; reverse l1 and l2
(F E D C B A)   

问题 （以前评论的摘要）

缩进、空格和名称错误；我更喜欢这个：

(defun new-union (l1 l2)
  (setq list (union l1 l2))
  (let (reversed) 
    (loop for x in list
          do (setq res (cons (car list) reversed))
          do (setq list (cdr list)))))

在未声明的全局变量上使用SETQ，而不是LET

正在迭代的结构的突变（列表）

在循环中不使用X（为什么要定义它？）

返回值始终为零

重构

• 定义一个本地

  reverse

  变量，默认情况下绑定为NIL（您可以将其设置为

  ”（）

  ，这有时是首选）
• 使用

  DOLIST

  迭代列表并执行副作用；第三个参数是返回值；在这里，您可以将

  reverse

  变量放在累积反向列表的位置
• 对于每个元素

  elt

  ，将其向前推到

  反向

  ；如果要避免出于学习目的而推送

  ，请使用
  （setf reverse（cons elt reverse））

Common Lisp是一种多范式的语言，支持实用的解决方案：有时循环更自然或更有效，没有理由强迫自己采用函数式风格

功能实现 然而，列表提供了一种自然的归纳结构：在某些情况下，递归方法可能更合适。 如果您想使用函数样式来计算反向，请注意，虽然尾部调用优化通常可用，但语言规范并不要求它（它取决于您的实现能力和编译器选项）

在默认设置下，SBCL消除了尾部位置的调用，并消除了使用大输入时堆栈溢出的风险。但是如果你不小心的话，还有其他可能的方法来获得糟糕的算法复杂性（和浪费的代码）。 下面是我用来定义并集和反向的组合的内容；特别是，我更喜欢使用

标签定义一个局部函数，以避免使用伪nil参数调用
新union
。此外，我只迭代一次由联合产生的列表

(defun new-union (l1 l2)
  (labels ((rev (list acc)
             (etypecase list
               (null acc)
               (cons (rev (rest list)
                          (cons (first list) acc))))))
    (rev (union l1 l2) nil)))

痕迹
评论
当并集应该在无序集上操作时，反转的结果是相当令人惊讶的：结果中元素的顺序不必以任何方式反映list-1或list-2的顺序。集合是无序集合，没有重复项；如果您的输入列表已经表示集合，正如函数名称（
newunion
）所暗示的那样，那么删除重复项或期望顺序有意义是没有意义的

相反，如果输入列表表示值序列，则顺序很重要；可以将
附加
或
连接
与
删除重复项
结合使用，但请注意，默认情况下后者将删除列表前面的元素：

(remove-duplicates (concatenate 'list '(4 5 6) '(2 3 4)))
=> (5 6 2 3 4)

您可能想改用
：from end t
。
您是在实现反向还是并集？您永远不会返回res。结果是最后计算的表达式的值，这里是循环，它通过累加子句或finally子句不产生值。顺便说一句，loop…do习语是一个dolist的等式。另外，你在L上调用setq，这是不好的：L应该是一个局部变量，用let声明，比如res。你在迭代L时修改L：最多你跳过列表中的其他元素，但这是危险的：loop已经在L上迭代了，您只需通过在res前面按每个连续的x来修改res。你就快到了。我看不出问题中有删除重复项的要求。OP在他的代码示例和解释中使用了union。Union删除重复项，因此我在解决方案中删除了重复项。规范不要求这样做：如果list-1或list-2中有重复项，则冗余项可能会出现，也可能不会出现在结果中。（）OP没有询问常见的口齿不清缺陷。并来自集合论，集合不包含重复项。集合论的使用向我暗示OP想要删除重复项。是的。我认为工会会隐式地处理重复项。因此，我们继续这样做。另外，感谢您提供了使用递归函数的技巧。我更习惯于来自oops编程的循环。看起来你的反转函数实际上并没有反转…它会洗牌
  0: (NEW-UNION (A B C) (D E F))
    1: (UNION (A B C) (D E F))
    1: UNION returned (C B A D E F)
    1: (REV (C B A D E F) NIL)
      2: (REV (B A D E F) (C))
        3: (REV (A D E F) (B C))
          4: (REV (D E F) (A B C))
            5: (REV (E F) (D A B C))
              6: (REV (F) (E D A B C))
                7: (REV NIL (F E D A B C))
                7: REV returned (F E D A B C)
              6: REV returned (F E D A B C)
            5: REV returned (F E D A B C)
          4: REV returned (F E D A B C)
        3: REV returned (F E D A B C)
      2: REV returned (F E D A B C)
    1: REV returned (F E D A B C)
  0: NEW-UNION returned (F E D A B C)

(remove-duplicates (concatenate 'list '(4 5 6) '(2 3 4)))
=> (5 6 2 3 4)