was ist die "Nachteile" so fügen Sie ein Element am Ende der Liste?

was ist der typische Weg, um ein Element am Ende der Liste?

Habe ich eine Liste (1 2 3), und hinzufügen möchten, 4 (wo 4 ist das Ergebnis einer Auswertung (+ 2 2))

(setf nlist '(1 2 3))  
(append nlist (+ 2 2))

Diese besagt, dass append erwartet eine Liste, nicht eine Zahl. Wie würde ich dies bewerkstelligen?

InformationsquelleAutor r b | 2011-06-22

26

Könnten Sie Anhängen, aber Vorsicht, dass es kann dazu führen, schlechte Leistung, wenn Sie in einer Schleife oder auf sehr langen Listen.
```
(append '(1 2 3) (list (+ 2 2)))
```
Wenn die Leistung wichtig ist, das übliche idiom ist der Aufbau von Listen durch voranstellen von (mit Nachteile), dann reverse (oder nreverse).

was empfehlen Sie für eine bessere Leistung bei großen Liste?
In der Regel, consing und Umkehr in Ordnung ist. Wenn Sie viele lange Listen, und die Umkehrung wird ein performance-problem, verwenden Sie eine andere Datenstruktur oder halten Sie einen Zeiger an das Ende der Liste manuell auswählen. (Es gibt ein paar Vorschläge in den anderen Antworten.)

InformationsquelleAutor danlei
6

Du noch nicht angegeben, die Art von Lisp, also, wenn Sie Emacs-Lisp-und Strich list manipulation-Bibliothek, es hat eine Funktion -snoc , liefert eine neue Liste mit dem element am Ende Hinzugefügt. Der name ist Umgekehrt "Nachteile".
```
(-snoc '(1 2) 3) ; (1 2 3)
```
InformationsquelleAutor Mirzhan Irkegulov
5

Wenn die "Nachteile an der front, beenden Sie, indem Sie umkehren" idiom ist nicht für Sie geeignet (wenn Sie. zum Beispiel müssen übergeben Sie die Liste auf, um andere Funktionen WÄHREND der Erstellung), es gibt auch die "keep track of the end" - trick. Jedoch, es ist wahrscheinlich sauberer zu bauen, die Liste von consing auf der Vorderseite, dann beenden Sie, indem Sie mit dem reverse-oder nreverse, bevor Sie schließlich mit.

Im wesentlichen, dies ermöglicht es Ihnen, die Liste in der richtigen Reihenfolge, während das Gebäude, die Kosten müssen im Auge behalten.
```
(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))
```
Dies gibt die folgende Ausgabe:
```
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)
```
Ich denke, diese Technik ist sehr vorzuziehen reverse-Bau-und Rückwärtsfahren. Wir können Ihnen auch eine spezielle tracking-Daten geben (cons list last_cons_cell) und spezielle Funktionen verwenden die es für die Zugabe am Ende wie (defun eadd (elt ls) (rplacd (cdr ls) (list elt)) (rplacd ls (cddr ls)) ls) etc.

InformationsquelleAutor Vatine
4

Können Sie auch nconc erstellen der Liste, das ist wie append, nur es ändert sich die Struktur der input-Listen.
```
(nconc nlist (list (+ 2 2)))
```
In Common Lisp verwenden NCONC nur, wenn nlist ist ein consed Liste, nicht wörtliche Daten.
Wohl besser nicht zu empfehlen NCONC für einen Anfänger überhaupt.
Nie, NIE verwenden, NCONC. Die side-Effekt wird kommen, beißen Sie in den Arsch. Und es ist auch nicht asymptotisch weniger Komplex als APPEND.
Nie, nie, niemals machen absolute Aussagen.

InformationsquelleAutor Trey Jackson
3

Diese Funktion könnte in manchen Situationen nützlich sein, es transparent hängt ein einzelnes element an eine Liste, D. H. es ändert sich die Liste aber gibt die angefügte element (eingeschlossen in eine Liste):
```
(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
```
Das ist ähnlich wie NCONC. (nconc lst (list x)).
Nein, es ist Verschieden von NCONC; mit diesem ATTACH1 Funktion brauchen Sie nicht (und dürfen Sie nicht) schließen Sie das element Hinzugefügt werden, in eine Liste.
(setf (cdr (last Liste)) (cons x nil)) = (nconc lst (cons x nil)) = (nconc lst (list x))
Wir haben unterschiedliche Vorstellungen von "ähnlich". Für mich zwei Funktionen, die unterschiedliche Art der Argumente (atom vs. Liste) sind nicht ähnlich, während Sie für Sie. Sowieso, unabhängig von der Einbringung in eine Liste, die element Anhängen, ich Stimme mit Ihnen überein.

InformationsquelleAutor mmj
1

Nachteile-ing an das Ende einer Liste erreicht werden kann mit dieser Funktion:
```
(defun cons-last (lst x)
  (let ((y (copy-list lst))) (setf (cdr (last y)) (cons x nil)) y))

;; (cons-last nlist (+ 2 2))
```
dies hat einen Nachteil, der beim navigieren in der Liste zweimal - zuerst mit copy-list -, die zweite mit last. Besser zu ändern, die track-trail von Vatine Antwort.

InformationsquelleAutor mmj

Wenn Sie versuchen, fügen Sie zwei Listen zum Beispiel (1 2 3) + (1 2 3) hier ist der code (rekursiv)

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

Wenn Sie versuchen, hinzufügen, ein Element am Ende der zweiten Liste, zum Beispiel 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)) ))
  )
)

InformationsquelleAutor Giri

1

(append l (list e)) ; e ist das element, das Sie hinzufügen möchten, in den Schwanz der Liste

InformationsquelleAutor Nadhem Jemmali
0

Wenn Sie ein Element hinzufügen möchten, auf das Ende einer Liste ohne änderung dieser Liste, dann wie bereits vorgeschlagen, können Sie eine Funktion verwenden, wie
```
(defun annex (lst item)
  "Returns a new list with item added onto the end of the given list."
  (nconc (copy-list lst) (list item)))
```
Diese gibt eine neue, erweiterte Liste, wobei die input-Liste. Allerdings, wenn Sie möchten, ändern Sie die input-Liste, um das hinzugefügte Element, dann können Sie ein makro verwenden, wie
```
(define-modify-macro pushend (item)
  (lambda (place item)
    (nconc place (list item)))
  "Push item onto end of a list: (pushend place item).")
```
Pushend wirkt wie push, sondern "schiebt" das Element wird an das Ende der übergebenen Liste. Beachten Sie auch die Reihenfolge der Argumente ist das Gegenteil von push.

InformationsquelleAutor davypough

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.