Verkette Listen

Status
Nicht offen für weitere Antworten.

kaper28

Bekanntes Mitglied
Liebe Freunde , ich habe wieder ein problem und zwar ...

Ich habe eine verkette Liste und möchte einen neuen element direkt am ende der Liste anhaengen ohne das die liste immer neu ermittelt wird.

Wie kann cih so was machen ? Ich muß eine Methode erstellen das mir das aktuelle Ende der Liste zurück liefert .. aber wie ?

Code:
/*######################################
 * Eine verkettete Liste Version 2
 ######################################*/

//die Klasse für die Listenelemente
//jetzt auch mit Methoden
class Listenelement {
		String daten;
		Listenelement naechster;

		//die Methode zum Setzen der Daten
		void setDaten(String datenNeu) {
			//die Zeichenkette setzen
			daten = datenNeu;
			//das Ende markieren
			naechster = null;
		}

		//die Methode zum Anhängen eines neuen Elements
		//sie ruft sich rekursiv auf, bis das Ende erreicht ist
		void anhaengen(String datenNeu) {
			//wenn das Ende erreicht ist, ein neues Element erzeugen
			if (naechster == null) {
				naechster = new Listenelement();
				naechster.setDaten(datenNeu);
			}
			//sonst ruft sich die Methode selbst wieder auf
			else
				naechster.anhaengen(datenNeu);
			//nur zur Veranschaulichung
			System.out.println("Daten " + datenNeu + " wurden eingefügt.");
		}

		//die Methode zur Ausgabe der Liste
		//sie ruft sich ebenfalls rekursiv auf, bis das Ende erreicht ist
		void ausgeben() {
			System.out.println(daten);
			if (naechster != null)
				naechster.ausgeben();
		}
}

public class Java05_10 {
	public static void main(String[] args) {
		//ein neues Listenelement erzeugen
		Listenelement listenAnfang = new Listenelement();
		Listenelement listenEnde = new Listenelement();
		//die Daten im ersten Listenelement setzen
		listenAnfang.setDaten("Element 1");
		

		//weitere Elemente in einer Schleife einfügen
		for (int element = 2; element < 4; element++)
			listenAnfang.anhaengen("Element " + element);
listenEnde.anhaengen(null);
		//die Liste ausgeben
		listenAnfang.ausgeben();
		
	}
}
 

AmunRa

Gesperrter Benutzer
Wieso machst du nicht einfach ein class MyList


Code:
class Mylist{
   Listenelement haed;
   Listenelement tail;

  public void append(Listenelement new){
     tail.setNext(new);
     tail=new;
  }
}



Code:
class Listenelement{
   private  Listenelement next
    ...

   public void setNext(Listenelement new){
          next= new
   }
}


Damit kannst du immer ganzleicht hinten etwas anhängen
 

AmunRa

Gesperrter Benutzer
andre111 hat gesagt.:
ich würd als Bezeichner nicht gerade new verwenden :)

Ja hast recht war ja blos schnell hingeschrieben

sollte viellecht dann eher so aussehen

Code:
class Mylist{ 
   Listenelement haed; 
   Listenelement tail; 

  public void append(Listenelement newElement){ 
     tail.setNext(newElement); 
     tail=newElement; 
  } 
}


aber sonst müsste es ja richtig sein
 

Landei

Top Contributor
Ich finde immutable Listen viel einfacher zu programmieren und sicherer zu verwenden:
Code:
import java.util.Iterator;
import java.util.NoSuchElementException;

/**
 *
 * @author Gronau
 */
public class MyList<T> implements Iterable<T> {

    private static final MyList EMPTY = new MyList(null, null) {

        @Override
        public boolean isEmpty() {
            return true;
        }

        @Override
        public Object head() {
            throw new UnsupportedOperationException();
        }

        @Override
        public MyList tail() {
            throw new UnsupportedOperationException();
        }

        @Override
        public int size() {
            return 0;
        }

        @Override
        public Void last() {
            throw new UnsupportedOperationException();
        }

        @Override
        public MyList drop(int n) {
            return this;
        }

        @Override
        protected MyList reverse(MyList accu) {
            return accu;
        }

        @Override
        public MyList append(MyList list) {
            return list;
        }
    };
    private final T head;
    private final MyList<T> tail;

    private MyList(T value, MyList<T> tail) {
        this.head = value;
        this.tail = tail;
    }

    public boolean isEmpty() {
        return false;
    }
    ;

    public T head() {
        return head;
    }

    public MyList<T> tail() {
        return tail;
    }

    public int size() {
        return 1 + tail.size();
    }

    public T last() {
        return tail.isEmpty() ? head : tail.last();
    }

    public MyList<T> drop(int n) {
        return n == 0 ? this : tail.drop(n - 1);
    }

    public MyList<T> reverse() {
        return reverse(EMPTY);
    }

    protected MyList<T> reverse(MyList<T> accu) {
        return tail.reverse(cons(head, accu));
    }

    public MyList<T> append(MyList<T> list) {
        for (MyList<T> rev = reverse(); !rev.isEmpty(); rev = rev.tail) {
            list = cons(rev.head, list);
        }
        return list;
    }

    public MyList<T> append(T t) {
        return append(make(t));
    }

    public Iterator<T> iterator() {
        return new Iterator<T>() {

            private MyList<T> current = MyList.this;

            public boolean hasNext() {
                return !current.isEmpty();
            }

            public T next() {
                if (!hasNext()) {
                    throw new NoSuchElementException();
                }
                T t = current.head;
                current = current.tail;
                return t;
            }

            public void remove() {
                throw new UnsupportedOperationException("Not supported");
            }
        };
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (MyList<T> list = this; !list.isEmpty(); list = list.tail) {
            sb.append(list.head.toString());
            sb.append(list.tail.isEmpty() ? "]" : ",");
        }
        return sb.toString();
    }

    public static <T> MyList<T> make(T... ts) {
        MyList<T> list = (MyList<T>) EMPTY;
        for (int i = ts.length - 1; i >= 0; i--) {
            list = cons(ts[i], list);
        }
        return list;
    }

    public static <T> MyList cons(T head, MyList<T> tail) {
        return new MyList<T>(head, tail);
    }
}
 

kaper28

Bekanntes Mitglied
Code:
/*######################################
 * Eine verkettete Liste Version 2
 ######################################*/

//die Klasse für die Listenelemente
//jetzt auch mit Methoden
class Listenelement {
		String daten;
		Listenelement naechster;

		//die Methode zum Setzen der Daten
		void setDaten(String datenNeu) {
			//die Zeichenkette setzen
			daten = datenNeu;
			//das Ende markieren
			naechster = null;
		}

		//die Methode zum Anhängen eines neuen Elements
		//sie ruft sich rekursiv auf, bis das Ende erreicht ist
		void anhaengen(String datenNeu) {
			//wenn das Ende erreicht ist, ein neues Element erzeugen
			if (naechster == null) {
				naechster = new Listenelement();
				naechster.setDaten(datenNeu);
			}
			//sonst ruft sich die Methode selbst wieder auf
			else
				naechster.anhaengen(datenNeu);
			//nur zur Veranschaulichung
			System.out.println("Daten " + datenNeu + " wurden eingefügt.");
		}

		//die Methode zur Ausgabe der Liste
		//sie ruft sich ebenfalls rekursiv auf, bis das Ende erreicht ist
		void ausgeben() {
			System.out.println(daten);
			if (naechster != null)
				naechster.ausgeben();
		}

		public void setNext(Listenelement newElement) {
			
			naechster= newElement; 

		}

}
class Mylist{ 
	   Listenelement haed; 
	   Listenelement tail; 

public void listenEnde(Listenelement newElement){ 
    tail.setNext(newElement); 
    tail=newElement; 
 } 
} 





public class Java05_10 {
	public static void main(String[] args) {
		//ein neues Listenelement erzeugen
		Listenelement listenAnfang = new Listenelement();
		Listenelement listenEnde = new Listenelement();
		//die Daten im ersten Listenelement setzen
		listenAnfang.setDaten("Element 1");
		

		//weitere Elemente in einer Schleife einfügen
		for (int element = 2; element < 3; element++)
			listenAnfang.anhaengen("Element " + element);
          
		//die Liste ausgeben
		//listenAnfang.ausgeben();
		listenEnde.ausgeben();
		
	}
}

Wenn ich jetzt diese Program starte dann bekommen ich null warum ?

Daten Element 2 wurden eingefügt.
null
das ist falsch denke ich ? Freunde ich habe sinn der Sache nicht verstanden , was versuche ich hier zur machen ? Bitte kann mir das einmal erklären ?
 

Landei

Top Contributor
Ich denke, das alles in Ordnung ist, außer dass du listenEnde nirgendwo benutzt. Bei listenAnfang.anhaengen wird ja ein neues Element erstellt, für das du aber keinen Variablennamen hast, mit dem du es aulesen könntest. Rufe statt
Code:
listenEnde.ausgeben();
Code:
 listenAnfang.naechster.ausgeben();
auf, da sollte "Element2" drinstehen.
 

kaper28

Bekanntes Mitglied
Code:
/*######################################
 * Eine verkettete Liste Version 2
 ######################################*/

//die Klasse für die Listenelemente
//jetzt auch mit Methoden
class Listenelement {
		String daten;
		Listenelement naechster;

		//die Methode zum Setzen der Daten
		void setDaten(String datenNeu) {
			//die Zeichenkette setzen
			daten = datenNeu;
			//das Ende markieren
			naechster = null;
		}

		//die Methode zum Anhängen eines neuen Elements
		//sie ruft sich rekursiv auf, bis das Ende erreicht ist
		void anhaengen(String datenNeu) {
			//wenn das Ende erreicht ist, ein neues Element erzeugen
			if (naechster == null) {
				naechster = new Listenelement();
				naechster.setDaten(datenNeu);
			}
			//sonst ruft sich die Methode selbst wieder auf
			else
				naechster.anhaengen(datenNeu);
			//nur zur Veranschaulichung
			System.out.println("Daten " + datenNeu + " wurden eingefügt.");
		}

		//die Methode zur Ausgabe der Liste
		//sie ruft sich ebenfalls rekursiv auf, bis das Ende erreicht ist
		void ausgeben() {
			System.out.println(daten);
			if (naechster != null)
				naechster.ausgeben();
		}

		public void setNext(Listenelement newElement) {
			
			naechster= newElement; 

		}

}
class Mylist{ 
	   Listenelement haed; 
	   Listenelement tail; 

public void listenEnde(Listenelement newElement){ 
    tail.setNext(newElement); 
    tail=newElement; 
 } 
} 





public class Java05_10 {
	public static void main(String[] args) {
		//ein neues Listenelement erzeugen
		Listenelement listenAnfang = new Listenelement();
		Listenelement listenEnde = new Listenelement();
		//die Daten im ersten Listenelement setzen
		listenAnfang.setDaten("Element 1");
		

		//weitere Elemente in einer Schleife einfügen
		for (int element = 2; element < 5; element++)
			listenAnfang.anhaengen("Element " + element);
          
		//die Liste ausgeben
		//listenAnfang.ausgeben();
		//listenEnde.ausgeben();
		listenAnfang.naechster.ausgeben();
	}
}

du meinst so , jetzt wird die listenende beim anhängen eines neues elements nicht mer neu ermittelt sondern direkt am ende angehängt ?

was ist der unterschied ? ich kappiere es nicht :oops:
 

Landei

Top Contributor
Schau einfach in deine anhängen-Methode
Code:
if (naechster == null) {
     naechster = new Listenelement();
     naechster.setDaten(datenNeu);
}
für naechster wird also ein neues Listenelement genommen - da ist keinerlei Verbindung zu deiner Variablen listenEnde. Was ist daran nicht zu verstehen?
 

Landei

Top Contributor
OK, hier eine so einfach wie möglich gehaltene Version, die sich stark an deiner orientiert:
Code:
public class Liste {

    private String head;
    private Liste tail;

    //Liste mit einem Element
    public Liste(String head) {
        this.head = head;
    }

    //Liste aus Kopf und vorhandener Restliste
    public Liste(String head, Liste tail) {
        this.head = head;
    }

    //Methode zum Anhängen eines neuen Elements
    public void append(String data) {
        last().tail = new Liste(data);
    }

    //Methode zum Ermitteln des letzten Elements
    public Liste last() {
        Liste last = this;
        while (last.tail != null) {
            last = last.tail;
        }
        return last;
    }

    //Methode zum Ausgeben der aktuellen Daten
    public String getData() {
        return head;
    }

    //Methode zum Ausgeben der Daten am angegebenen Index
    public String getData(int index) {
        Liste l = this;
        while (l != null) {
            if (index == 0) {
                return l.head;
            }
            index--;
            l = l.tail;
        }
        throw new java.util.NoSuchElementException();
    }

    //Methode zum Ändern der aktuellen Daten
    public void setData(String head) {
        this.head = head;
    }

    //Methode zum Ändern der Daten am angegebenen Index
    public void setData(int index, String data) {
        Liste l = this;
        while (l != null) {
            if (index == 0) {
                l.head = data;
                return;
            }
            index--;
            l = l.tail;
        }
        throw new java.util.NoSuchElementException();
    }

    //Gibt die Restliste zurück
    public Liste getTail() {
        return tail;
    }

    //Ermittelt die Länge
    public int size() {
        Liste l = this;
        int size = 0;
        while (l != null) {
            size++;
            l = l.tail;
        }
        return size;
    }
    
    //String für die Ausgabe
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("[");
        Liste l = this;
        while (l.tail != null) {
            sb.append(l.head).append(",");
            l = l.tail;
        }
        sb.append(l.head).append("]");
        return sb.toString();
    }
}
Alles wirklich einfach, keine Generics, Schleifen statt Rekursion usw.

Und die Verwendung:
Code:
      Liste l = new Liste("hallo");
      l.append("welt");
      l.append("wie");
      l.append("gehts?");
      System.out.println(l); //-> [hallo,welt,wie,gehts?]
      System.out.println(l.last()); //-> [gehts?]
      System.out.println(l.size()); //-> 4
      System.out.println(l.getData(2)); //-> wie
      System.out.println(l.getData(4)); //-> java.util.NoSuchElementException
 
Status
Nicht offen für weitere Antworten.
Ähnliche Java Themen
  Titel Forum Antworten Datum
llabusch Verkette Listen - Einfach und Doppelt Java Basics - Anfänger-Themen 3
K Verkette Listen ? Java Basics - Anfänger-Themen 6
thor_norsk Verkette Liste Java Basics - Anfänger-Themen 27
O Doppelt verkette Liste Element löschen Java Basics - Anfänger-Themen 15
J Doppelt verkette Liste ich bitte um Hilfe Java Basics - Anfänger-Themen 4
S Einfach verkette Liste Java Basics - Anfänger-Themen 27
C Zyklisch verkette Liste - Pop() methode implementieren Java Basics - Anfänger-Themen 2
C Methoden Einfach verkette Liste - int Werte aufsteigend sortieren Java Basics - Anfänger-Themen 1
H Datentypen Doppelte Verkette Liste - Verständnissproblem Java Basics - Anfänger-Themen 5
C verkette liste sortieren? Java Basics - Anfänger-Themen 7
W Rekursion und verkette Liste Java Basics - Anfänger-Themen 5
I einfach verkette Liste Java Basics - Anfänger-Themen 9
L doppelt verkette Liste Java Basics - Anfänger-Themen 5
H doppelt verkette liste Java Basics - Anfänger-Themen 2
D Listen in Listen in Listen ... ??? Java Basics - Anfänger-Themen 2
XWing listen Java Basics - Anfänger-Themen 7
FunkyPhil94 addLast und addFirst bei Listen Java Basics - Anfänger-Themen 6
S Einfach-Verkettete-Listen Ausgabe zeigt nur 1. und letzte instanz Java Basics - Anfänger-Themen 2
J 2 listen vergleichen, die auch null Elemente haben können ! Java Basics - Anfänger-Themen 9
W Liste mit Listen in JTable darstellen Java Basics - Anfänger-Themen 1
Buroto Threads Verschiedene .txt Dateien Auf Listen und Verbinden Java Basics - Anfänger-Themen 3
M Generics Vererbung Listen Java Basics - Anfänger-Themen 2
T Collections Sind Subklassen-Objekte in Listen mit Generics erlaubt? Java Basics - Anfänger-Themen 16
S Lineare listen verkettung Java Basics - Anfänger-Themen 7
S Listen Java Basics - Anfänger-Themen 12
S Listen , Nodes am ende anängen Java Basics - Anfänger-Themen 6
P Sortieren von Listen nach Attributen Java Basics - Anfänger-Themen 3
M Java Listen Java Basics - Anfänger-Themen 4
V einfach verkettete Listen Java Basics - Anfänger-Themen 10
A PhoneBook mit verketteten listen Java Basics - Anfänger-Themen 48
F ich brauche Hilfe bei Listen Java Basics - Anfänger-Themen 13
M (Sehr großes Problem) Listen als static in anderen Klassen verwendet Java Basics - Anfänger-Themen 12
G Java Listen und Iterator Java Basics - Anfänger-Themen 2
S Erklaerung Listen Java Basics - Anfänger-Themen 27
J Implementierung Listen-ADT Java Basics - Anfänger-Themen 131
I Alle Elemente von zwei Listen vergleichen Java Basics - Anfänger-Themen 1
L Skip Listen Java Basics - Anfänger-Themen 5
S Collections funktionale Listen (ListNode<E>) review und problem beim clone Java Basics - Anfänger-Themen 0
L Wie testet man (selbstgeschriebene) Listen sinnvoll? Java Basics - Anfänger-Themen 2
F Problem mit Listen Java Basics - Anfänger-Themen 5
J Listen Operationen Java Basics - Anfänger-Themen 4
O Unterschied Arrays, Listen, Mengen Java Basics - Anfänger-Themen 24
J Eine Liste von Listen erstellen Java Basics - Anfänger-Themen 11
A Sortierte Listen Java Basics - Anfänger-Themen 4
L Datenstrukturen/ Listen Java Basics - Anfänger-Themen 17
A Was könnten typische Prüfungsaufgaben zum Thema lineare, verkettete Listen sein? Java Basics - Anfänger-Themen 5
L Listen und Felder Java Basics - Anfänger-Themen 2
M Fragen zum Anlegen und Benutzen von Listen Java Basics - Anfänger-Themen 9
R Arrays und Listen Java Basics - Anfänger-Themen 1
R Listen richtig implementieren Java Basics - Anfänger-Themen 3
F Multidimensionale Listen Java Basics - Anfänger-Themen 3
F Wie String in unterschiedliche Listen teilen Java Basics - Anfänger-Themen 7
R Interface Eigene Objekte in Listen sortieren mit Interface Comparable Java Basics - Anfänger-Themen 5
T Objekte in Listen vererben Java Basics - Anfänger-Themen 3
A Klassen Klassen und Listen... Java Basics - Anfänger-Themen 5
Hacer Operationen einfach verketteter Listen Java Basics - Anfänger-Themen 22
S Methoden Vergleichen von zwei Listen in der Geschwindigkeit von O(n+m) Java Basics - Anfänger-Themen 32
P Listen sortieren mit Binärbaum gibt keine Ausgabe ab 10000 Integern Java Basics - Anfänger-Themen 14
C Listen Java Basics - Anfänger-Themen 3
C Zwei Listen verbinden Java Basics - Anfänger-Themen 1
C Zahlen merken mit Hilfe von Arrays/Listen Java Basics - Anfänger-Themen 2
E Feld von verketteten Listen Java Basics - Anfänger-Themen 11
T Überprüfung einer Aufgabe zu verketteten Listen Java Basics - Anfänger-Themen 5
S Liste mit Objekten und Listen Java Basics - Anfänger-Themen 9
JarJarBigs Frage zu Listen Java Basics - Anfänger-Themen 2
N verkettete Listen Java Basics - Anfänger-Themen 4
O Listen sort-Methode Java Basics - Anfänger-Themen 1
I Listen sortieren bei mehreren Listen zu einer Java Basics - Anfänger-Themen 2
L Lineare Listen Java Basics - Anfänger-Themen 2
S Listen Objekte nach LocalDateTime sortieren Java Basics - Anfänger-Themen 2
D Methoden Listen generieren Java Basics - Anfänger-Themen 4
A Sichtbarkeit in Methoden/Listen Java Basics - Anfänger-Themen 3
M verkettete Listen Java Basics - Anfänger-Themen 1
D Klausur Vorbereitung: Listen, Rekursion, Bäume & Vererbung Java Basics - Anfänger-Themen 3
S Vergleich von Listen Java Basics - Anfänger-Themen 6
I Zwei Listen vergleichen Java Basics - Anfänger-Themen 2
M Listen erstellen mit unterschiedlichen Reihenfolgen Java Basics - Anfänger-Themen 3
I Zwei Listen vergleichen bei n:m Beziehung Java Basics - Anfänger-Themen 2
I Zwei Listen: Wenn nicht vorhanden löschen Java Basics - Anfänger-Themen 4
I Prüfen von zwei Listen Java Basics - Anfänger-Themen 1
K Interface Generics, Interfaces und Listen - ich bin verwirrt. Java Basics - Anfänger-Themen 7
L Best Practice Alle Kombinationen aus Listenelementen, Anzahl Listen unterschiedlich Java Basics - Anfänger-Themen 6
S Unsortierte Listen - Frage zur "Verkettung" Java Basics - Anfänger-Themen 1
I Zwei Listen vergleichen Java Basics - Anfänger-Themen 7
I Listen, for - Schleifen Java Basics - Anfänger-Themen 8
P Listen Size stimmt nicht Java Basics - Anfänger-Themen 5
O Objekt Listen serialisierung und deserialisieren Java Basics - Anfänger-Themen 5
L Collections Objekte in Listen speichern Java Basics - Anfänger-Themen 3
G 2 Listen kombinieren und nach abc sortieren Java Basics - Anfänger-Themen 9
D Annonyme Innere Klasse: Listen mit geradem Index ausgeben Java Basics - Anfänger-Themen 6
G Listen sortieren Java Basics - Anfänger-Themen 3
G Generic und Listen Java Basics - Anfänger-Themen 8
R SQL ähnlicher Filter für Java Listen Java Basics - Anfänger-Themen 2
Y Collections 4 Listen Java Basics - Anfänger-Themen 14
S OOP/ Listen...etc... Java Basics - Anfänger-Themen 14
E Listen Java Basics - Anfänger-Themen 2
V Methoden Verkettete Listen Index eines Elementes ausgeben Java Basics - Anfänger-Themen 10
B Listen Java Basics - Anfänger-Themen 3
B eigene klasse in listen eintragen Java Basics - Anfänger-Themen 6
B Map per Listen Java Basics - Anfänger-Themen 2

Ähnliche Java Themen

Neue Themen


Oben