Wie addiert man die Elemente einer Verketteten Liste?

[1101100]

Hallo,

ich muss in Java eine Methode summe() schreiben, die die Werte aller Elemente einer Liste addiert.
Ich könnte ja schreiben summe = list.head.obj + list.head.next.obj + list.head.next.next.obj ....

Aber wie mache ich sowas dann allgemein und für eine variable Anzahl an Elementen?


Mit freundlichen Grüßen
11011100


Hier noch der Code:

package uebung8;
/**
 * Die Klasse VerketteteListe berechnet die Summe aller hinzugefuegten Knoten 
 * in der verketteten Liste.
 *
 * Bitte aendern Sie an dieser Stelle nichts. Sollte der Name anders sein als 
 * definiert, tritt waehrend des Tests ein Fehler auf und Ihre Loesung wird als 
 * falsch bewertet!
 */
public class VerketteteListe {
    ////////////////////////////////////////////////////////////////////////////
    // Start der Klasse Node
    ////////////////////////////////////////////////////////////////////////////
    /**
     * Dies ist die Definition der Klasse Node
     *
     * Ein Object dieser Klasse repraesentiert einen Knoten in einer einfach
     * verketteten Liste.
     *
     * Beachten Sie die Klammern: Die Klasse Node ist innerhalb der Klasse List
     * definiert!
     */
    private static class Node {
        int obj; // der "Wert" des Knotens
        Node next;  // der Nachfolger in der Liste

        /**
         * Erstellt einen neuen Knoten ohne Wert und ohne Nachfolger
         */
        public Node() {
            obj = 0;
            next = null;
        }
        /**
         * Erstellt einen neuen Knoten mit einem Wert.
         * @param o Der Wert des neuen Knotens.
         */
        public Node(int o) {
            obj = o;
            next = null;
        }
        //Setter und Getter-Methoden
        public void setElement(int o) {
            obj = o;
        }
        public int getElement() {
            return obj;
        }
        public void setNext(Node n) {
            next = n;
        }
        public Node getNext() {
            return next;
        }
    } 
    ////////////////////////////////////////////////////////////////////////////
    // Ende der Klasse Node
    ////////////////////////////////////////////////////////////////////////////

    
    /**
     * Markiert den Kopf der Liste
     */
    private Node head;

    /**
     * Konstruktor zum Erzeugen einer neuen verketteten Liste.
     */
    public VerketteteListe() {
        this.head = null;
    }
    
    /**
     * Fuegt ein neues Element am Ende der vorhandenen Liste ein.
     * @param wert Der einzufuegende Wert.
     */
    public void hinzufuegen(int wert) {
        if(this.head == null) {
            //Fuege das erste Element ein
            this.head = new Node(wert);
        } else {
            //Fuege die restlichen Elemente am Ende ein
            Node prev;
            Node tmp;
            Node newNode;
            
            prev = tmp = this.head;
            do {
                //Sichere das aktuelle Element
                prev = tmp;
                //Erhalte das naechste Element
                tmp = tmp.getNext();
                //Testet ob das naechste Element belegt ist
            } while(tmp != null);
            //Erzeuge einen neuen Knoten
            newNode = new Node(wert);
            //Fuege den neu erzeugten Knoten am Ende ein
            prev.setNext(newNode);
        }
    }
    
    public static int summe(VerketteteListe list) {
    	int s = list.head.obj + list.head.next.obj + list.head.next.next.obj;
    	
    	
    	return s;
    }


    public static void main(String[] args) {
        //Erzeugt ein neues Objekt der Klasse
        VerketteteListe list = new VerketteteListe();
        //Fuegt neue Knoten hinzu
        list.hinzufuegen(10);
        list.hinzufuegen(20);
        list.hinzufuegen(3);
        list.hinzufuegen(7);
        list.hinzufuegen(5);
        list.hinzufuegen(2);
        
        
        System.out.println(summe(list));
    }
}

 

[Androbin]

Hast du schon mal etwas von einer for-Schleife gehört?

 

[1101100]

ja, aber wie hilft mir das weiter?

 

[Androbin]

Wer for-Schleifen kennt, sollte sie auch benutzen können:

public void summeAllerElemente() {
    
    int summe = 0;
    
    for ( int nummer = 0; nummer < anzahlDerElemente; nummer++ )
        summe += elementMitDerNummer( nummer ).getWert();
    
    return summe;
    
}

Den Rest solltest du jetzt aber auch alleine schaffen.

 

[1101100]

Ich habe es jetzt so gelößt:

public int summe() {
    	int s=0;
    	if(this.head != null) {
    		s = this.head.getElement();
    		Node NextNode = this.head;
        	while(NextNode.getNext()!=null) {
        		NextNode = NextNode.getNext();
        		s += NextNode.getElement();
        	}
    	}
    	
    	return s;
    }

 

[coco07]

Wie man das löst, ist schlussendlich egal. Aber wenn man die Anzahl der Durchläufe kennt, scheint eine for Schleife moderner...

Grüße coco07