# Operationen verketteter Liste implementieren



## regtan (22. Jun 2016)

Hallo , ich muss drei Methoden implementieren in eine Programm und der sieht so aus :

```
public class ListNode {
   private final int content;
   private ListNode successor;

   public ListNode(int content) {
     this.content = content;
   }

   public int content() {
     return content;
   }

   public void setSuccessor(ListNode node) {
     successor = node;
   }

   public ListNode successor() {
     return successor;
   }

   public static int itemsCount(ListNode head) {
     int counter = 0;
      if (head != null){
       counter += itemsCount(head.successor);
       counter++;
       return counter;
      
      }else{
        return 0;
      }
   }
//kommt ein andere Nummer raus
   public static int sumItems(ListNode head) {
     int summe = 0;
     if (head != null){
       //summe = head.content();
       for(int i = 0; i <itemsCount(head); i++){
         summe += head.content();
       }
       return summe;
     }else{
       return -1;
     }
   }

   // hier auch kommt nicht der genaue wert raus
   public static ListNode appendItem(ListNode head, int content) {
     ListNode node = new ListNode(content);
     while(head != null) {
       head = head.successor();
       node = head;
       return node;
     }
    
     return node;
   }
```

in die 2 letzte Methode kommen nicht richtige werte raus. Wo könnte das Problem liegen?


----------



## Joose (22. Jun 2016)

regtan hat gesagt.:


> in die 2 letzte Methode kommen nicht richtige werte raus. Wo könnte das Problem liegen?



Was kommt denn bei dir raus? Was sollte denn rauskommen?
Selber schon probiert mit dem Debugger herauszufinden woran es denn liegt?


----------



## regtan (22. Jun 2016)

Debugger geht nicht weil dieses Programm hat kein '' main '' . Es wird untersucht ob die Methode für beliebige Werte richtig funktioniert und bei sumItems methode sollte die summe raus kommen. (z.b. Summe von Liste mit vier Knoten mit Inhalten 123, 77, 2 und 10 expected:<212> but was:<492>) . So bei ListNode appendItem methode sollte ein neu element dazu in die Liste anlegen.


----------



## InfectedBytes (22. Jun 2016)

Anstatt alle Items aufzusummieren, summierst du immer nur das head-Element auf:

```
public static int sumItems(ListNode head){
     int summe =0;
     if(head !=null){
       //summe = head.content();
       for(int i =0; i <itemsCount(head); i++){
         summe += head.content();
       }
       return summe;
     }else{
       return-1;
     }
   }
```
Wenn also itemsCount == 4 ist, addierst du viermal head.content()

Du musst die liste durchlaufen und immer das aktuelle Element aufaddieren:

```
ListNode currentNode = head;
int sum = 0;
while(currentNode != null) {
  sum += currentNode.content();
  currentNode = currentNode.successor();
}
```


----------



## regtan (22. Jun 2016)

```
ListNode currentNode = head;
  int sum = 0;
  while(currentNode != null) {
  sum += currentNode.content();
  currentNode = currentNode.successor();
  return sum;
```

addiert die wieder nicht. kommt das raus: 
Summe von Liste mit vier Knoten mit Inhalten 123, 77, 2 und 10 expected:<212> but was:<123>


----------



## Joose (22. Jun 2016)

regtan hat gesagt.:


> Debugger geht nicht weil dieses Programm hat kein '' main '' .


Naja dann könntest du dir doch eine schreiben und einfach mal die Liste mit ein paar Testwerten füllen und die Funktionalität prüfen.


----------



## mrBrown (22. Jun 2016)

regtan hat gesagt.:


> ```
> ListNode currentNode = head;
> int sum = 0;
> while(currentNode != null) {
> ...


Dein return steht in der while, `sum += currentNode.content();` wird also nur genau einmal ausgeführt.


----------



## VfL_Freak (22. Jun 2016)

regtan hat gesagt.:


> Summe von Liste mit vier Knoten mit Inhalten 123, 77, 2 und 10 expected:<212> but was:<123>


ist auch logisch, weil Du nach dem ersten Summieren sofort mit _*return*_ raus springst !!
Gruß Klaus

EDIT: zu langsam :-(


----------



## regtan (22. Jun 2016)

ja das habe ich sofort gemerkt  aber bei ListNode appendItem methode sehe ich immer noch nicht den Fahler. DANKE!


----------



## VfL_Freak (22. Jun 2016)

aha ... und was sollte da rauskommen rsp. kommt stattdessen raus ???


----------



## regtan (22. Jun 2016)

*Test nicht bestanden*

appendsNewNodeAtEndOfListWithThreeItems
Inhalt von zurückgegebenem, neuen Knoten expected:<36> but was:<35>
appendsNewNodeAtEndOfListWithTwoItems
Inhalt von zurückgegebenem, neuen Knoten expected:<36> but was:<34>
appendsNewNodeAtEndOfListWithOneItem
Inhalt von zurückgegebenem, neuen Knoten expected:<12> but was:<33>


----------



## VfL_Freak (22. Jun 2016)

regtan hat gesagt.:


> _
> 
> 
> Java:In die Zwischenablage kopieren
> ...


Wir reden doch von diesem Code, richtig?
Ist er so aktuell ??

mit welchen Werten wird er aufgerufen??
Sicher, dass *head != null* ist ??
Sicher, dass mit *content* die entsprechenden Werte übergeben werden ??

Gruß Klaus


----------



## regtan (22. Jun 2016)

Ja für den Code. Ich glaube es ist wurscht welche Werte aufgerufen werden, hauptsächlich wird der neue Wert angehängt. oder??


----------



## VfL_Freak (22. Jun 2016)

regtan hat gesagt.:


> Ich glaube es ist wurscht welche Werte aufgerufen werden, hauptsächlich wird der neue Wert angehängt. oder??


Wieso _angehängt_ ??

wenn etwa "head==null" ist, dann wird lediglich ein neues Objekt "_ListNode"_ erzeugt (mit dem Wert "content") und zurückgegeben .....


----------



## regtan (22. Jun 2016)

So lautet die Aufgabe: 
Implementieren Sie die Methode ListNode appendItem(ListNode head, int content) (Java).
Diese soll an die Liste, die mit dem in head übergebenen ListNode-Objekt beginnt, einen neuen Knoten mit dem in content übergebenen Inhalt anhängen. Geben Sie das neu erzeugte ListNode-Objekt zurück.
Beachten Sie, dass die Liste auch leer sein kann, dann ist head == null.


----------



## InfectedBytes (22. Jun 2016)

wenn head==null ist, musst du head auf deinen neu erzeugten Node setzen.


----------



## regtan (22. Jun 2016)

ich hatte so geändert:

```
public static ListNode appendItem(ListNode head, int content) {
     ListNode node = new ListNode(content);
     if(head == null) {
       head = node;
     }else {
     ListNode nextNode = head;
     while (nextNode.successor != null){
       nextNode = nextNode.successor;
     }
     return nextNode;
     }
     
     return node;
   }
```

hab vergessen zu aktualisieren.


----------



## mrBrown (22. Jun 2016)

mit der while-Schleife findest du aktuell nur das letzte Element der Liste, und gibst dieses zurück. Du sollst aber an die Liste etwas anhängen, und dann das Erstelle zurückgeben, die Logik dafür fehlt noch.


----------



## regtan (22. Jun 2016)

ja stimmt. ich versuche die "node" als head.successor zu bezeichnen aber geht nicht. gibt es eine besondere code das ich schreiben um die "node" anzuhängen?


----------



## mrBrown (22. Jun 2016)

Es gibt da so eine Methode namens #setSuccessor


----------



## regtan (22. Jun 2016)

aber klarrrr so doof von mir  danke!!


----------

