каковы «минусы» добавления элемента в конец списка?

Вы можете использовать append, но имейте в виду, что это может привести к снижению производительности, если используется в цикле или в очень длинных списках.

(append '(1 2 3) (list (+ 2 2)))

Если важна производительность, обычная идиома заключается в создании списков путем добавления в начало (используя cons), затем обратное (или nreverse).

Если идиома «против» в начале, «закончить путем реверсирования» вам не подходит (если вам, например, нужно передать список другим функциям ВО ВРЕМЯ его построения), есть также трюк с отслеживанием конца. Тем не менее, вероятно, будет чище просто построить список, переместив его в начало, а затем закончить, используя reverse или nreverse, прежде чем, наконец, использовать его.

По сути, это позволяет вам иметь список в правильном порядке при его создании за счет необходимости отслеживать его.

(defun track-tail (count)
  (let* ((list (cons 0 nil))
         (tail list))
    (loop for n from 1 below count
       do (progn
        (setf (cdr tail) (cons n nil))
        (setf tail (cdr tail))
        (format t "With n == ~d, the list is ~a~%" n list)))
    list))

Это дает следующий результат:

CL-USER> (track-tail 5)
With n == 1, the list is (0 1)
With n == 2, the list is (0 1 2)
With n == 3, the list is (0 1 2 3)
With n == 4, the list is (0 1 2 3 4)
(0 1 2 3 4)

Вы не указали тип Lisp, поэтому, если вы используете Emacs Lisp и библиотеку dash для работы со списками , у него есть функция -snoc, которая возвращает новый список с элементом, добавленным в конец. Название перевернуто "минусы".

(-snoc '(1 2) 3) ; (1 2 3)

Вы также можете использовать nconc для создания списка, похожего на append, только он изменяет структуру входных списков.

(nconc nlist (list (+ 2 2)))

Эта функция может быть полезна в некоторых ситуациях, она прозрачно добавляет один элемент в список, т. е. изменяет список, но возвращает добавленный элемент (заключенный в список):

(defun attach1 (lst x)
  (setf (cdr (last lst)) (cons x nil)))

;; (attach1 nlist (+ 2 2)) ; append without wrapping element to be added in a list

Cons-ing в конце списка может быть достигнуто с помощью этой функции:

(defun cons-last (lst x)
  (let ((y (copy-list lst))) (setf (cdr (last y)) (cons x nil)) y))

;; (cons-last nlist (+ 2 2))

Если вы пытаетесь добавить два списка, например (1 2 3) + (1 2 3), вот код (рекурсивный)

(defun add-to-all (x y)
    (T (appendl (+ (first x) (first y)) (add-to-all (tail x) (tail y)) ))
)

Если вы пытаетесь добавить элемент в конец второго списка, например 3 + (1 2 3)

(defun add-to-all (x y)
  (cond ((null? y) nil)
    (T (appendl (+ (first x) (first y)) (add-to-all (tail x) (tail y)) ))
  )
)

(добавьте l (список e)) ; e — это элемент, который вы хотите добавить в конец списка

Если вы хотите добавить элемент в конец заданного списка, не изменяя этот список, то, как предлагалось ранее, вы можете использовать такую ​​функцию, как

(defun annex (lst item)
  "Returns a new list with item added onto the end of the given list."
  (nconc (copy-list lst) (list item)))

Это возвращает новый расширенный список, сохраняя при этом список ввода. Однако, если вы хотите изменить список ввода, чтобы включить добавленный элемент, вы можете использовать макрос, например

(define-modify-macro pushend (item)
  (lambda (place item)
    (nconc place (list item)))
  "Push item onto end of a list: (pushend place item).")

Pushend работает как push, но «толкает» элемент в конец заданного списка. Также обратите внимание, что порядок аргументов обратный push.