[Fienchen]

Hallo;
wenn cih zwei listen habe l1 und l2 wie kan ich de denn zusammenfügen; also:
li={2,3,4,5}
l2=[6,7,8,9}
l=[2,6,3,7,4,8,5,9}???
Ich gehe davon aus das ich eine abstrakte klassse list mit den unterklassen cons und nil habe (nil ist die leere liste)

wenn man eine solche rekursive Struktur hat, ist eine rekursive Methode empfehlenswert. Ich hoffe, ich habe eine Struktur mit cons und nil im Internet gefunden, die zu dem Problem passt.

Die Funktion basiert auf ganz einfachen Regeln:

Zunächst wird das Ende der Rekursiion abgefragt: Wenn eine der beiden Listen leer ist, ist die andere Liste das Resultat (wenn man später an den Listen herumfuhrwerken will, sollte man nicht die Liste selbst nehmen, sondern eine Kopie der Liste...)

Wenn keine der beiden Listen leer ist, wird von jeder Liste der Kopf entfernt, die beiden Tails miteinander gemergt und anschließend die beiden Köpfe vorne dran gefügt.

//Funktionale Listen mit Cons und Nil
 
public class ListAdder {
    public static void main(String[] args) {
        // Die Listen sind rückwärts eingetragem weil in add ein Fehler vorliegt...
        List l1 = List.nil.add(new Integer[] {5, 4, 3, 2});
        List l2 = List.nil.add(new Integer[] {9, 8, 7, 6});
        List l = merge(l1, l2);
    }
    
    public static List merge(List l1, List l2)
    {
        if (l1.isNil())
            return l2;
        if (l2.isNil())
            return l1;
        return List.cons(l1.hd(), List.cons(l2.hd(), merge(l1.tl(), l2.tl())));
    }
}
/**
 * Dies ist eine Implementierung von funktionalen Listen mit einer Konstanten
 * nil, die die leere Liste repräsentiert und einer Klassenmethode cons(hd,tl)
 * für die Cons-Operation. Jedesmal, wenn eine Element zu einer Liste
 * hinzugefügt wird, wird ein neue Liste erzeugt anstatt die alte Liste zu
 * verändern.
 * 
 * @author Hubert Baumeister
 */
abstract class List {
 
    // Die Klassenvariable nil enthält die leere Liste
 
    /**
     * Die Konstante nil repräsentiert die leere Liste.
     */
    public static final List nil = new Nil();
 
    // Klassenmethode um eine Liste zu erzeugen:
 
    /**
     * Diese Operation erzeugt eine neue Liste mit hd als Kopf und tl als Rest.
     */
    public static List cons(Object hd, List tl) {
        return new Cons(hd, tl);
    }
 
    // Listen werden mit List.nil und l.add konstruiert.
 
    List() {
    };
 
    // Instanzmethoden:
 
    /**
     * Gibt den Kopf von this zurück. Es wird eine EmptyListException erzeugt,
     * falls this keine Elemente enthält.
     */
    public abstract Object hd();
 
    /**
     * Gibt this ohne den Kopf zurück. Es wird eine EmptyListException erzeugt,
     * falls this keine Elemente enthält.
     */
    public abstract List tl();
 
    /**
     * Fügt die Liste l an this an.
     */
    public abstract List append(List l);
 
    /**
     * Liefert true, wenn this die leere Liste ist, false sonst.
     */
    public boolean isNil() {
        return false;
    }
 
    /**
     * Es wird eine neue Liste erzeugt mit Kopf hd und this als dem Rest.
     */
    public List add(Object o) {
        return new Cons(o, this);
    }
 
    /**
     * Diese Operation fügt alle Elemente des Arrays der Reihe nach zu this
     * hinzu.
     */
    public List add(Object[] oa) {
        List l = this;
        for (int i = 0; i < oa.length; i++)
            l = l.add(oa[i]);
        return l;
    }
}
 
class Nil extends List {
 
    // Instanzmethoden
 
    public Object hd() {
        throw new EmptyListException();
    }
 
    public List tl() {
        throw new EmptyListException();
    }
 
    public boolean isNil() {
        return true;
    }
 
    public List append(List l) {
        return l;
    }
    
    public String toString() {
        return "<nil>";
    }
}
 
class Cons extends List {
 
    // Instanzvariablen
 
    Object hd;
 
    List tl;
 
    // Konstruktor
 
    Cons(Object h, List t) {
        hd = h;
        tl = t;
    }
 
    // Instanzmethoden
 
    public Object hd() {
        return hd;
    }
 
    public List tl() {
        return tl;
    }
 
    public List append(List l) {
        return new Cons(hd, tl.append(l));
    }
    
    public String toString() {
        return "" + this.hd + " " + this.tl;
    }
    
}
 
class EmptyListException extends RuntimeException {
    EmptyListException() {
        super();
    }
}

Die Klassen mit Ausnahme der Klasse ListAdder und EmptyListException stammen von der Webseite http://www.mpi-sb.mpg.de/~hubert/PS9...list/List.java. Die toString Methoden habe ich selbst hinzugefügt.