faecher:informatik:oberstufe:adt:verkettete_liste:liste_java:lengthvalue

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Nächste Überarbeitung		 Vorherige Überarbeitung
faecher:informatik:oberstufe:adt:verkettete_liste:liste_java:lengthvalue [20.10.2021 18:56] – angelegt sbelfaecher:informatik:oberstufe:adt:verkettete_liste:liste_java:lengthvalue [23.11.2023 16:02] (aktuell) – [n-ten Wert auslesen] Marco Kuemmel
Zeile 1: Zeile 1:
 +====== Länge der Liste bestimmen/Wert auslesen  ======
  
-===== Einfügen eines neuen Elements =====+===== Listenlänge =====
  
-Das Einfügen eines neuen Knotens ist im folgenden Objektdiagramm dargestellt. Man muss beim ändern der Objektreferenzen (''nextNode'') darauf achten, dass die Reihenfolge stimmt und man die Referenz auf den ursprünglichen Nachfolger des Knotens, hinter dem der neue Knoten eingefügt wird nicht verliert. ((Hier: Aufpassen, dass man ''node2'' nicht "verliert", sonst ist die Liste an dieser Stelle unterbrochen und alle Nachfolger werden von der Garbage Collection entsorgt...)) 
  
-{{ :faecher:informatik:oberstufe:adt:verkettete_liste:liste_java:insert.drawio.png?700 |}} +Die Länge der Liste kann man bestimmen, indem man sich vom ersten Element zum letzten bewegt und dabei mit einem Zähler die verarbeiteten Elemente mit zählt.
- +
-{{:aufgabe.png?nolink  |}} +
-=== (A2) === +
-Schreibe als Merksatz stichwortartig nieder, was beim Einfügen eines neuen Knotens nach dem n-ten vorhandenen Knoten alles passieren muss. Gibt es Fälle, die gesondert behandelt werden müssen?+
  
 ----  ---- 
 {{:aufgabe.png?nolink  |}} {{:aufgabe.png?nolink  |}}
-=== (A3) ===+=== (A1) ===
  
-Implementiere die Methode ''insertAt'', so dass man damit ein neues Element nach dem n-ten  Listenelement einfügen kann.  +  * Implementiere die Methode ''length'' 
-Teste deine Methode, indem du Elemente in eine Liste einfügst und mit dem Objektinspektor überprüfst, dass das neue Element an der richtigen Stelle eingefügt wurde - und dass die Nachfolgenden Knoten noch erreichbar sind.+  * Teste deine Methode mit unterschiedlich langen Listen. Welchen Fall solltest du unbedingt testen?
  
 ++++ Lösungsvorschlag | ++++ Lösungsvorschlag |
-Kann sicher weiter optimiert werden. 
 <code java> <code java>
     /**     /**
-     * Fügt einen neuen Wert an einer gewünschten Stelle in der Liste ein. +     * Gibt die Anzahl der Elemente der Liste zurück 
-     * @param index Die Stelle, an der der neue Wert stehen soll (0 <= index <= laenge()) +     *  
-     * @param val Der einzufügende Wert+     * @return   Anzahl der Listenelemente
      */      */
-    public void insertAt(int index, T val) {+    public int length() { 
 +        int numElements = 0;
                  
-        // Der neue Knoten +        Node<T> n = first;
-        Node<T> new_node = new Node(val, null);+
                  
-        // Wenn der Index groesser als die Laenge ist  +        if ( n == null) { 
-        // passiert nix +            return numElements;
-        if (this.length() < index) { +
-            return;+
         }         }
-        +         
-        // Wenn der Index Null ist, muss das Element als erster neuer +        numElements++; 
-        // Knoten eingefuegt werden +         
-        if (index == 0) { +        while ( n.getNext() != null ) { 
-            new_node.setNext(first); +            n = n.getNext(); 
-            first = new_node; +            numElements++;
-            return;+
         }         }
-        // In allen anderen Faellen muss das n-te Element  +         
-        // aufgesucht werden und der neue Knoten dort eingefügt werden.+        return numElements; 
 +    } 
 +</code> 
 +++++ 
 +===== n-ten Wert auslesen ===== 
 + 
 +{{:aufgabe.png?nolink  |}} 
 +=== (A2) === 
 + 
 +Überlege dir eine Möglichkeit, eine Referenz auf das n-te Element der Liste zu ermitteln und implementiere zunächst eine **neue** (private) Methode ''getNode(int index): Node'', die eine Referenz auf den n-ten Knoten zurückliefert. 
 + 
 + 
 +  * Welche Werte für n sollten akzeptiert werden? 
 +  * Mit welchem Sprachkonstrukt kann man das n-te Element ansteuern? 
 +  * Was sollte zurückgegeben werden, wenn der n-te Knoten nicht ermittelt werden kann? 
 + 
 + 
 +++++ Lösungsvorschlag |  
 +<code java> 
 +    /** 
 +     * Gibt eine Referenz auf den n-ten Knoten der Liste zurück.  
 +     * Wenn der n-te Knoten nicht ermittelt werden kann null 
 +     *  
 +     * @return Node, wenn der n-te Knoten gefunden wird, sonst null 
 +     */ 
 +     private Node getNode(int index) { 
 +         
 +        if (index < 0 || index > this.length()-1) { 
 +            return null; 
 +        } 
 +        
         Node<T> n = first;         Node<T> n = first;
-        for (int i=1; i<index; i++) {+        for (int i=0; i<index; i++) {
             n = n.getNext();             n = n.getNext();
         }         }
                  
-        new_node.setNext(n.getNext()); +        return n;
-        n.setNext(new_node); +
-        +
     }     }
 </code> </code>
-+++++++++  
 + 
 +----  
 +{{:aufgabe.png?nolink  |}} 
 +=== (A3) === 
 + 
 +Verwende die oben implementierte private Methode ''getNode(int index): Node'', um damit die Methode ''getValueAtN'' zu programmieren, die den Wert des n-ten Knotens zurückgibt. 
 + 
 +---- 
 + 
 +<btn>[[..:liste_java:append|<<< Zurück zum Anhängen (am Ende)]]</btn> **oder** <btn>[[..:liste_java:insert|Weiter zum Einfügen (am Index) >>>]]</btn>
  • faecher/informatik/oberstufe/adt/verkettete_liste/liste_java/lengthvalue.1634756189.txt.gz
  • Zuletzt geändert: 20.10.2021 18:56
  • von sbel