# einfach verkettete Liste



## scr3tchy (17. Nov 2009)

Hallo Leute,

ich fall gleich mal mit der tür ins haus.
ich soll eine einfach verkettete Liste programmieren, wo ich eine nummer und einen namen eingeben soll. Nun bin ich schon den ganzen tag am gucken und ausprobieren. ich habe hier schon versucht den quellcode so zu ändern dass ich ein Tupel eingeben kann aber irgendwie komm ich da nich weiter. Nun habe ich das hier versucht ... aber ich nehme an, dass ich das einfügen der elemente noch nich ganz so richtig is...weiß aber nich wie ich das ändern kann. mein quellcode sieht momentan wie folgt aus.

```
public class einfacheListe{
	// Datentyp für ein Element der Liste:
    private class ListenElement
    {
        private int           nutzdaten_1;  // die Daten eines Elements
        private String 		  nutzdaten_2;	// die Daten eines Elements
        private ListenElement next;       // Verweis auf Nachfolger

        public ListenElement( int Zahl, String Name )
        {
            nutzdaten_1 = Zahl;
            nutzdaten_2 = Name;
            next = null;
        }

        // fügt hinter sich ein neues Element ein:
        public void einf_dahinter( int Zahl, String Name )
        {
            // dazu den bisherigen Nachfolger merken, um
            // ihn später als Nach-Nachfolger einsetzen zu können:
            ListenElement uebernaechster = next;

            // neues Element schaffen und anhängen:
            next = new ListenElement( Zahl, Name );

            // bisherigen Nachfolger dahinter setzen:
            next.setNext( uebernaechster );
        }

        public void setZahl( int Zahl )
        {
            nutzdaten_1 = Zahl;
        }

        public int getZahl()
        {
            return nutzdaten_1;
        }
        
        public void setName( String Name )
        {
        	nutzdaten_2 = Name;
        }
        
        public String getName()
        {
        	return nutzdaten_2;
        }

        public void setNext( ListenElement next_neu )
        {
            next = next_neu;
        }

        public ListenElement getNext()
        {
            return next;
        }
 /*
        // sucht nach einem Wert, und liefert das ListenElement
        // (falls gefunden), oder null.
        public ListenElement sucheWert( int Zahl )
        {
            // Schleife notfalls über alle Elemente:
            ListenElement aktuellesElement = this;
            do
            {
                if( aktuellesElement.getZahl() == Zahl )
                {
                    return aktuellesElement;
                }
                aktuellesElement = aktuellesElement.getNext();
            }
            while( aktuellesElement.getNext() != null );

            // wenn alle Elemente nicht passen, dann ist die Suche
            // fehlgeschlagen:
            return null;
        }

        // sucht nach dem Vorgänger eines Werts, und liefert das
        // ListenElement (falls gefunden), oder null.
        public ListenElement sucheVorgaengerVonWert( int Zahl )
        {
            // Schleife notfalls über alle Elemente:
            ListenElement aktuellesElement = this;
            do
            {
                if( aktuellesElement.next != null
                    &&
                    aktuellesElement.next.getZahl() == Zahl
                    )
                {
                    return aktuellesElement;
                }
                aktuellesElement = aktuellesElement.getNext();
            }
            while( aktuellesElement.getNext()!=null );

            // wenn alle Elemente nicht paßten, dann ist die Suche
            // fehlgeschlagen:
            return null;
        }
*/
        // Ausgabe einer Liste in einen String:
        // Element ausgeben, dann ggf. den Rest
        public String toString()
        {
            return ( " El." + nutzdaten_1 + nutzdaten_2
                     + ( next==null ? "." : ", " + next.toString() )
                     );
        	//return (nutzdaten_1 + nutzdaten_2);
        }        
    } // class ListenElement


    private ListenElement   anfang;

    public einfacheListe()
    {
        anfang = null;
    }

    // fügt einen neuen Wert am Anfang ein:
    public void einf_vorn( int Zahl, String Name )
    {
        // das bisherige erste Element merken, um es später zum
        // zweiten zu machen (auch wenn das bisherige erste
        // null ist, also die Liste bisher leer ist):
        ListenElement  zweites = anfang;

        // ein neues erstes Element erzeugen, und mit wert
        // initialisieren:
        anfang = new ListenElement( Zahl , Name );

        // das bisherige erste Element (oder null) hinten
        // anhängen:
        anfang.setNext( zweites );
    }

    // fügt einen neuen Wert am Ende ein:
    public void einf_hinten( int Zahl, String Name )
    {
        // Wenn die Liste noch leer ist, dann einfach ein
        // Element an den Anfang setzen:
        if( anfang == null )
        {
            anfang = new ListenElement( Zahl , Name );
        }
        else
        {
            // Suche nach dem letzten Element:
            ListenElement letztes = anfang;
            while( letztes.getNext()!= null )
            {
                letztes = letztes.getNext();
            }
            // letztes hat jetzt keinen Nachfolger mehr.
            // Das wird geändert:
            letztes.einf_dahinter( Zahl , Name );
        }
    }
    
/*
    // versucht, ein neues Element wert hinter einem gegebenen Wert
    // hinterwas einzusetzen.
    // Das kann natürlich fehlschlagen, wenn das Element, hinter
    // dem eingefügt werden soll, gar nicht existiert.
    // Dementsprechend wird true zurückgegeben, wenn alles geklappt
    // hat; sonst false.
    public boolean einf_HinterWert( int hinterwas, int Zahl , String Name )
    {
        // Leere Liste?
        if( anfang == null )
        {
            return false;
        }
        else
        {
            ListenElement element = anfang.sucheWert( hinterwas );
            if( element==null )
            {
                return false;
            }
            else
            {
                element.einf_dahinter( Zahl , name );
                return true;
            }
        }
    }
*/
} // public class einfacheListe
```

hoffe ihr könnt mir irgendwie helfen, dass ich ein Tupel in mein Liste eingeben kann.


----------



## eRaaaa (17. Nov 2009)

```
einfacheListe liste = new einfacheListe();
		 liste.einf_vorn(1, "scr3tchy");
```

??


----------



## scr3tchy (17. Nov 2009)

Ja na das hab ich ja auch ... eine Main habe ich mir geschrieben ... aber das Programm gibt mir meine Liste nicht aus ... das is momentan so das problom ...


----------



## scr3tchy (18. Nov 2009)

vielleicht habe ich mein problem nicht eindeutig beschrieben... 
also ich habe wiegesagt die oben gegebene klasse so geändert das ich erstmal das tupel aus einer nummer und einen namen eingeben kann. jetzt bin ich mir nich sicher ob das programm das auch wirklich so speichert. auch die ausgabe funktioniert nicht. normalerweise ist in der klasse die funktion toString die ausgabefunktion für die ausgabe, doch leider gibt er mir das nicht aus. nun komme ich an dem punkt nicht weiter.....


----------



## lumo (18. Nov 2009)

scr3tchy hat gesagt.:


> vielleicht habe ich mein problem nicht eindeutig beschrieben...
> also ich habe wiegesagt die oben gegebene klasse so geändert das ich erstmal das tupel aus einer nummer und einen namen eingeben kann. jetzt bin ich mir nich sicher ob das programm das auch wirklich so speichert. auch die ausgabe funktioniert nicht. normalerweise ist in der klasse die funktion toString die ausgabefunktion für die ausgabe, doch leider gibt er mir das nicht aus. nun komme ich an dem punkt nicht weiter.....



System.out.println() ist für die ausgabe zuständig
toString() ist nur das, was er ausgibt, wenn du eine liste an sysout übergibst...
von selbst macht er keine ausgabe...

zeig mal deine main() her...


----------



## Landei (18. Nov 2009)

```
public class SimpleList {

  // Datentyp für ein Element der Liste:
  private static class ListElement {
    private int number; // die Daten eines Elements
    private String name; // die Daten eines Elements
    private ListElement next; // Verweis auf Nachfolger

    public ListElement(int number, String name, ListElement next) {
      this.number = number;
      this.name = name;
      this.next = next;
    }

    // fügt hinter sich ein neues Element ein:
    public void append(int number, String name) {
      if (next == null) {
        next = new ListElement(number, name, null);
      } else {
        next.append(number, name);
      }
    }
    
    public ListElement search(int number) {
      if (this.number == number) {
        return this;
      } else {
        return next == null ? null : next.search(number);
      }
    }

    public void setNumber(int number) {
      this.number = number;
    }

    public int getNumber() {
      return number;
    }

    public void setName(String name) {
      this.name = name;
    }

    public String getName() {
      return name;
    }

    public void setNext(ListElement next) {
      this.next = next;
    }

    public ListElement getNext() {
      return next;
    }

    // Ausgabe einer Liste in einen String:
    // Element ausgeben, dann ggf. den Rest
    @Override
    public String toString() {
      return ("" + number + ":" + name
              + (next == null ? "" : ", " + next.toString())
          );
    }
  } // class ListenElement

  private ListElement first = null;

  // fügt einen neuen Wert am Anfang ein:
  public void insertFirst(int number, String Name) {
    // ein neues erstes Element erzeugen, und mit wert
    // initialisieren:
    first = new ListElement(number, Name, first);
  }

  // fügt einen neuen Wert am Ende ein:
  public void append(int number, String name) {
    // Wenn die Liste noch leer ist, dann einfach ein
    // Element an den Anfang setzen:
    if (first == null) {
      first = new ListElement(number, name, null);
    } else {
      first.append(number, name);
    }
  }
  
  public static void main(String... args) {
    SimpleList list = new SimpleList();
    list.append(2,"zwei");
    list.append(3,"drei");
    list.append(4,"vier");
    list.insertFirst(1,"eins");
    System.out.println(list);
  }
  
  public ListElement search(int number) {
     return first == null ? null : first.search(number);
  }
  
  @Override
  public String toString() {
    return first == null ? "Empty List" : "[" + first.toString() + "]";
  }

}
```

Klassen-Namen GrossUndCamelCase. Variablen-Namen kleinUndCamelCase. Innere Klassen immer statisch (es sei denn, man benötigt die erzeugende Instanz der äußeren Klasse). _Eine_ Sprache verwenden , im Zweifelsfall immer englisch. Member-Variablen normalerweise wie die Argumente benennen (name, number). Operationen möglichst in den Elementen programmieren, nicht von außen mit Schleifen (append, search).


----------



## ARadauer (18. Nov 2009)

Ich würde das ListenElement als eigene Klasse definieren und nicht als innere Klasse.
Das einf_dahinter würde ich nicht in die Klasse ListenElement geben. Ich würde das von der Liste Steuern lassen und das Element dumm lassen...

sonst schaut das gut aus... Ich denke das deine Ausgabe einfach falsch ist...


----------



## ARadauer (18. Nov 2009)

```
public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		EinfacheListe l = new EinfacheListe();
		l.listeAusgeben();
		System.out.println("==============");
		
		l.einf_hinten(1, "AA");
		l.listeAusgeben();
		System.out.println("==============");
		
		l.einf_hinten(2, "BB");
		l.listeAusgeben();
		System.out.println("==============");
		
		l.einf_vorn(3, "vorne");
		l.listeAusgeben();
		System.out.println("==============");
	}

}
```


```
public class EinfacheListe{
    
 
    private ListenElement anfang;
 
    public EinfacheListe()
    {
        anfang = null;
    }
 
    // fügt einen neuen Wert am Anfang ein:
    public void einf_vorn( int Zahl, String Name )
    {
        // das bisherige erste Element merken, um es später zum
        // zweiten zu machen (auch wenn das bisherige erste
        // null ist, also die Liste bisher leer ist):
        ListenElement  zweites = anfang;
 
        // ein neues erstes Element erzeugen, und mit wert
        // initialisieren:
        anfang = new ListenElement( Zahl , Name );
 
        // das bisherige erste Element (oder null) hinten
        // anhängen:
        anfang.setNext( zweites );
    }
 
    // fügt einen neuen Wert am Ende ein:
    public void einf_hinten( int Zahl, String Name )
    {
        // Wenn die Liste noch leer ist, dann einfach ein
        // Element an den Anfang setzen:
        if( anfang == null )
        {
            anfang = new ListenElement( Zahl , Name );
        }
        else
        {
            // Suche nach dem letzten Element:
            ListenElement letztes = anfang;
            while( letztes.getNext()!= null )
            {
                letztes = letztes.getNext();
            }
            // letztes hat jetzt keinen Nachfolger mehr.
            // Das wird geändert:
            
            ListenElement neues = new ListenElement( Zahl , Name );
            
            letztes.setNext(neues);
        }
    }    
    public void listeAusgeben(){
    	// Suche nach dem letzten Element:
        ListenElement aktuelles = anfang;
        if(aktuelles==null){
        	System.out.println("Liste leer");
        	return;
        }
        System.out.println(aktuelles);
        while( aktuelles.getNext()!= null ){
        	aktuelles = aktuelles.getNext();
        	System.out.println(aktuelles);
        }
    }

} // public class einfacheListe
```


```
// Datentyp für ein Element der Liste:
    public class ListenElement
    {
        private int           nutzdaten_1;  // die Daten eines Elements
        private String        nutzdaten_2;  // die Daten eines Elements
        private ListenElement next;       // Verweis auf Nachfolger
 
        public ListenElement( int Zahl, String Name )
        {
            nutzdaten_1 = Zahl;
            nutzdaten_2 = Name;
            next = null;
        } 

 
        public void setZahl( int Zahl )
        {
            nutzdaten_1 = Zahl;
        }
 
        public int getZahl()
        {
            return nutzdaten_1;
        }
        
        public void setName( String Name )
        {
            nutzdaten_2 = Name;
        }
        
        public String getName()
        {
            return nutzdaten_2;
        }
 
        public void setNext( ListenElement next_neu )
        {
            next = next_neu;
        }
 
        public ListenElement getNext()
        {
            return next;
        }

        public String toString()
        {
            return ( " El." + nutzdaten_1 + nutzdaten_2 );
            //return (nutzdaten_1 + nutzdaten_2);
        }        
    } // class ListenElement
```

ja funktioniert...
Wie gesagt ich würde das Listelement als eigene klasse definieren und dumm lassen...


----------



## scr3tchy (18. Nov 2009)

Vielen Dank an euch alle für die Hilfe.

funktioniert alles bestens. ich bin totaler anfänger und hab jetzt noch ein problem....wenn ich die veärnderungen von ARadauer nehme haut wie gesagt perfekt hin  aber die Ausgabe gefällt mir noch nicht. wie müsste ich das denn ändern dass die Nummer von dem Namen getrennt sein soll....beispielsweise von einem komma.....

edit:
ah ne ... sorry leute...habs selbst schon gefunden ..... danke nochmal für eure hifle


----------



## lumo (18. Nov 2009)

meinst du sowas:


```
public String toString()
        {
            return ( " El." + nutzdaten_1 + "," + nutzdaten_2 );
            //return (nutzdaten_1 + nutzdaten_2);
        }
```


----------



## scr3tchy (18. Nov 2009)

ja genau...hab ich jetzt aber selber schon gefunden 
vielleicht sollte ich mir angewöhnen erst zu gucken und dann zu schreiben :bae:
Danke nochmal...


----------



## ARadauer (18. Nov 2009)

scr3tchy hat gesagt.:


> vielleicht sollte ich mir angewöhnen erst zu gucken und dann zu schreiben :bae:



:applaus:


----------



## scr3tchy (18. Nov 2009)

so nun habe ich erfolgreich noch einige funktionen hinzugefügt.
jetzt stehe ich bloß vor dem problem beim löschen. 
mir ist klar das wenn ich ein element der liste rausschmeißen will muss ich die zeiger umsortieren. 
aber wie mache ich das in java???
momentan bin ich so weit:

```
public void loesche(int Zahl){
    	int pruefziffer = 0;
    	ListenElement aktuelles = anfang;
    	if(aktuelles == null){
    		System.out.println("Die Liste ist momentan noch leer!");
    	} else {
    		while (aktuelles.getNext() != null){
    			if(aktuelles.getNext().getZahl() == Zahl){
    				int IntTemp = aktuelles.getNext().getNext().getZahl();
    				String StringTemp = aktuelles.getNext().getNext().getName();
    				//aktuelles.getNext().getZahl() = IntTemp;
    				pruefziffer = 1;
    			}
    			aktuelles = aktuelles.getNext();
    		}
    		if (pruefziffer == 0){
        		System.out.println("Der Nummer " + Zahl + " existiert nicht in der Liste und konnte deshalb nicht gelöscht werden!");
        	}
    	}
    } // public void loesche()
```


----------



## lumo (18. Nov 2009)

da du eine einfach verkettete liste hast, wirst du nicht drum rum kommen die liste von vorn durchzugehn und dem vorgänger den nachfolger des zu löschenden elements zuzuweisen.
hättest du eine doppelt verlinkte liste könntest du dir dieses durchgehn sparen.


```
if(aktuelles.getNext().getZahl() == Zahl){
                    aktuelles.setNext(aktuelles.getNext().getNext());
                }
```

so müsste das eigentlich passen


----------



## Landei (18. Nov 2009)

Statt int pruefziffer nimmt man üblicherweise ein boolean, etwa 

```
boolean found = false;
...
   if(...) {
       ...  
       found = true;  
   }
...
if(found) {
   ...
}
```


----------



## scr3tchy (18. Nov 2009)

ja gut...ob ich nun so oder anders...läuft ja aufs gleiche hinaus ....
jetzt hab ich erstmal alles ... vielen dank nochmal an euch alle...


----------



## scr3tchy (19. Nov 2009)

Hey leute,

ich bin jetzt nochmal auf ein problem gestoßen.
ich möchte gerne das beim einfügen eine überprüfung statt findet ob die nummer bereits in der liste existiert. ich hab mal was programmiert aber ich weiß nich genau wo da der fehler is...könnt ihr mir nochmal helfen????



```
public void einf_hinten( int Zahl, String Name ){
    	int pruefziffer = 0;
        // Wenn die Liste noch leer ist, dann einfach ein
        // Element an den Anfang setzen:
        if( anfang == null ){
            anfang = new ListenElement( Zahl , Name );
        } else {
        	while (anfang.getNext() == null){
        		if (anfang.getZahl() == Zahl){
        			pruefziffer = 1;
        			System.out.println("Die Matr.-Nr. "+Zahl+" existiert bereits und konnte deshalb nicht eingefühgt werden!");
        		}
        		anfang = anfang.getNext();
        	}
        }
        
        if (pruefziffer != 1){
            // Suche nach dem letzten Element:
            ListenElement letztes = anfang;
            while( letztes.getNext()!= null )
            {
                letztes = letztes.getNext();
            }
            // letztes hat jetzt keinen Nachfolger mehr.
            // Das wird geändert:
            
            ListenElement neues = new ListenElement( Zahl , Name );
            
            letztes.setNext(neues);
        }
    } // public void einf_hinten()
```


----------



## Schumi (19. Nov 2009)

```
while(anfang.getNext() != null)
```
 und vielleicht solltest Du die Prüfziffer auch im ersten if auf 1 setzen. Sonst wird der Eintrag wohl 2 mal eingefügt.


----------



## scr3tchy (19. Nov 2009)

mhm...jetzt hab ich aber irgendwie das problem dass mir nich alle elemente aufgeführt werden die in der liste sind....woran kann das denn nun liegen????


----------



## lumo (20. Nov 2009)

was sollte dieser code machen?

```
public void einf_hinten( int Zahl, String Name ){
        int pruefziffer = 0;
        // Wenn die Liste noch leer ist, dann einfach ein
        // Element an den Anfang setzen:
        if( anfang == null ){
            anfang = new ListenElement( Zahl , Name );
        } else {
            while (anfang.getNext() == null){
                if (anfang.getZahl() == Zahl){
                    pruefziffer = 1;
                    System.out.println("Die Matr.-Nr. "+Zahl+" existiert bereits und konnte deshalb nicht eingefühgt werden!");
                }
                anfang = anfang.getNext();
            }
        }
        
        if (pruefziffer != 1){
            // Suche nach dem letzten Element:
            ListenElement letztes = anfang;
            while( letztes.getNext()!= null )
            {
                letztes = letztes.getNext();
            }
            // letztes hat jetzt keinen Nachfolger mehr.
            // Das wird geändert:
            
            ListenElement neues = new ListenElement( Zahl , Name );
            
            letztes.setNext(neues);
        }
    } // public void einf_hinten()
```

1) wenn das anfangselement null ist erstelle eines und setz zahl und name...
2) wenn 1) nicht zutrifft:
    solgange der nachfolger vom anfang null ist (es IST das letzte element in der liste) machst du was
err ich glaub dass das keinen sinn macht...
wäre es nicht sinngerechter zu sehen ob anfang gleich der zahl ist und ob anfang.next nicht null ist?


----------

