Question

我试图在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)

我认为我做错了循环。

Answer 1

问题

（以前评论的摘要）

错误的缩进，空格和名称;更喜欢这个：

(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
正在迭代的结构的变异（LIST）
在LOOP中不使用X（为什么定义它？）
返回值始终为NIL

重构

(defun new-union (l1 l2)
  (let ((reverse))
    (dolist (elt (union l1 l2) reverse)
      (push elt reverse))))

定义一个本地reverse变量，默认绑定到NIL（您可以将其设置为'()，这有时是首选。）
使用DOLIST迭代列表并执行副作用;第三个参数是返回值;在这里，您可以将reverse变量放在我们累积反转列表的位置。
对于每个元素elt，请将其推送到reverse;如果您想避免push用于学习目的，请使用(setf reverse (cons elt reverse))。

Common Lisp是一种多范式，有利于实用的解决方案：有时循环更自然或更有效，没有理由强迫自己采用功能风格。

功能实施

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

使用默认设置，SBCL可以消除尾部位置的调用，并可以消除大输入堆栈溢出的风险。但是，如果你不小心，还有其他可能的方法可以获得糟糕的算法复杂性（以及浪费的代码）。以下是我用来定义联合和反向组合的内容;特别是，我更喜欢使用labels定义一个本地函数，以避免使用伪nil参数调用new-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)))

微量

  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)

备注

当联合应该在无序集合上运行时，反转union的结果是非常令人惊讶的：结果中元素的顺序不必反映list-1的顺序或者以任何方式列出-2。集合是没有重复的无序集合;如果您的输入列表已经表示集合，正如函数名称（new-union）暗示的那样，则删除重复项或期望订单有意义是没有意义的。

相反，如果输入列表代表值序列，那么顺序很重要;您可以append或concatenate与remove-duplicates结合使用，但请注意，默认情况下，后者会删除列表前面的元素：

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

您可能希望改用:from-end t。

Answer 2

好的......我想你想要两个列表，将它们组合在一起，删除重复项，然后反转它们。

你最大的问题是你使用的是循环而不是递归。 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)

创建列表

2 个答案:

问题

重构

功能实施

微量

备注