PhoneBook mit verketteten listen

arhzz

Bekanntes Mitglied
Hallo!

Ich muss ein Programm erstellen der einen PhoneBook "simulieren soll".Nämlich soll ich ein interface implementieren der methoden enthält und diese methoden sollen folgendes machen. Lookup sollte eine Person suchen und wen der Name gleich ist soll es das Person objekt züruckliefern. Die methode Insert und Delete sind e schön klar.Ich habe versucht alles zu implementieren aber es klappt nicht so gut.

Java:
class PhoneBookList implements PhoneBook {
    private int size = 0;
    Node head = null;
    
    public Person lookup(String name) {
        Node p = head;
        int pos = 0;
        
        while( p!=null) {
            int comparison = p.compareTo(name);
            
        if(comparison == 0)
            return person;
        else Out.println("Person does not exist");
            return false;
        }
    }
    
    public boolean insert(Person person) {
        Node p = head;
        Node prev = null;
        
        while( p!=null) {
        
        Node n = new Node(person);
        n.next = p;
        
        if(prev == null) {
            head = n;
        }else{
            prev.next = n;
      }
        size++;
    }
  }
    public boolean delete(String name) {
        Node p = head;
        Node prev = null;
        
        while( p!=null) {
            prev = p;
            p = p.next;
            int comparison = p.compareTo(name);
            
        if(comparison == 0) {
            prev.next = p.next;
            return true;
        }else {
            Out.println("The person does not exist");
            return false;
        }
        size--;
    }
}   
    public int size() {
        Out.println(size);
    }
    
    static final class Node {
        final Person person;
        Node next;
        
        Node(Person person) {
            this.person = person;
            
        }
    }
    @Override
  public String toString() {
    return String.format("%-10s, %-20s, %-10s", name, address, phoneNr);
  }       

}

Wir sollen auch diese compareTo methode verwenden,aber ich bin mir nicht sicher wie dass gehen soll, und ich habe auch eine Klasse Person;

Java:
class Person {

  final String name;
  final String address;
  final String phoneNr;

  Person(String name, String address, String phoneNr) {
    this.name = name;
    this.address = address;
    this.phoneNr = phoneNr;
  }

  @Override
  public String toString() {
    return String.format("%-10s, %-20s, %-10s", name, address, phoneNr);
  }

}

Ein bisschen hilfe wäre gut, Danke!
 
K

kneitzel

Gast
Spiel deinen Algorithmus doch einmal durch! Also Stift und Zettel nehmen und von Hand alles machen ...

In der while schleife prüft du das erste Element. Ist es nicht das gesuchte, dann gibt es das Element nicht?
Und nach dem else hast du zwei Befehlee, da fehlen die geschweiften Klammern!

Delete fällt direkt auf, dass dein size-- nie erreicht werden kann ...

Also ggf. Willst du erst einmal in Worten erläutern, wie du in der Liste ein Element finden kannst ... generell Unterteil Probleme. Das könnte so aussehen:
- zu gesuchtem Element gehen
- Ergebnis zurück geben.
 

arhzz

Bekanntes Mitglied
Spiel deinen Algorithmus doch einmal durch! Also Stift und Zettel nehmen und von Hand alles machen ...

In der while schleife prüft du das erste Element. Ist es nicht das gesuchte, dann gibt es das Element nicht?
Und nach dem else hast du zwei Befehlee, da fehlen die geschweiften Klammern!

Delete fällt direkt auf, dass dein size-- nie erreicht werden kann ...

Also ggf. Willst du erst einmal in Worten erläutern, wie du in der Liste ein Element finden kannst ... generell Unterteil Probleme. Das könnte so aussehen:
- zu gesuchtem Element gehen
- Ergebnis zurück geben.
Ok,ich sehe was ich machen kann.
 

temi

Top Contributor
Es ist auch geschickt, wenn du dir nicht mehrere Probleme gleichzeitig antust. Fang mit einer Methode an und teste sie mit dem Debugger (oder mit Hilfsausgaben), bis sie korrekt funktioniert. Danach mach mit der nächsten weiter, usw.

Also: insert() -> size() -> delete() -> lookup()
 

arhzz

Bekanntes Mitglied
Deine Klasse Person sollte das Interface Comparable<Person> implementieren. Die Methode gibt 0 zurück, wenn beide Objekte gleich sind.
Also in der Angabe steht so; "Verwenden Sie die Methode int compareTo(String other) der Klasse String für den Vergleich von Personennamen. Diese Methode liefert 0, wenn ein String gleich other ist, einen negativen Wert, wenn ein String lexikographisch vor other steht, und einen positiven Wert, wenn ein String lexikographisch nach other steht", dass mit dem Interface Comparble ist mir bekannt, wir haben diesen interface schon benutzt
 

MoxxiManagarm

Top Contributor
Das widerspricht sich nicht

Java:
class Person implements Comparable<Person> {
  private String name;
  // ...

  @Override
  public int compareTo(Person other) {
    return this.name.compareTo(other.name);
  }
}



Aber ich war trotzdem gedanklich irgendwie daneben, du sollst ja nach dem Namen suchen und nicht sortieren oder sowas... Aber ehrlich gesagt ergbt sich mir nicht der Sinn, warum ihr dann compareTo anwenden sollt anstatt einfach equals \o/
 
Zuletzt bearbeitet:

arhzz

Bekanntes Mitglied
Das widerspricht sich nicht

Java:
class Person implements Comparable<Person> {
  private String name;
  // ...

  @Override
  public int compareTo(Person other) {
    return this.name.compareTo(other.name);
  }
}



Aber ich war trotzdem gedanklich irgendwie daneben, du sollst ja nach dem Namen suchen und nicht sortieren oder sowas...
Ja ich sollte nach dem namen suchen.Und das Person objekt züruckliefern.
 

arhzz

Bekanntes Mitglied
Okay,also ich habe eine neu Strategie versucht um mein Problem zu lösen.Nämlich habe ich den Rat von einen von euch befolgt den Code zu Unterteilne.Logischer weisse soll ich zuerst die insert methode Implementieren, und dass habe ich versucht.Ich habe auch ein bisschen über die compareTo methode gelesen und ich denke ich weiss wie ich sie verwenden soll.Aber jetzt bin ich nicht sicher wie ich sich dass alles mit boolean machen soll.Boolean sollte doch immer 2 ruckwerte haben true und false,und ich denke dass ich den wert true richtig Implementiere aber wie ich false züruck geben soll,wenn die Namen gleich sind.Vielleicht noch ein Paar Tipps? Danke!


Java:
class PhoneBookList implements PhoneBook {
    private int size = 0;
    Node head = null;
    
    private static final class Node {
        final Person person;
        Node next;
        
        Node(Person person) {
            this.person = person;
        }
    }
    
    public boolean insert(Person person) {
        Node p = head, prev = null;
        
        while(p!=null) {
            int comparison = person.name.compareTo(person.name);
            
          if(comparison != 0) {
            size++;
            return true;
         }
            if(comparison == 0) {
            prev = p;
            p = p.next;
          }
      }
    
    Node n = new Node(person);
      if (prev == null){
          head = n;
      }
      else{
          prev.next = n;
          n.next = p;
      }
    }
}
 

MoxxiManagarm

Top Contributor
Du vergleichst hier z.B. die Person mit sich selbst: person.name.compareTo(person.name). Beim Einfügen musst du mit -1 und 1 arbeiten, du willst die Person ja zwischen einer "kleineren" und einer "größeren" Person einfügen
 
K

kneitzel

Gast
Also ich würde dir raten erst einmal den Algorithmus in Worte zu fassen, damit die Hürde der Programmiersprache entfällt.

Deine while Schleife geht so lange weiter, wie der Vergleich 0 (Elemente sind gleich, wobei du noch nicht das aktuelle Element mit dem einzufügenden vergleichst) ergibt. So die Elemente nicht gleich sind, fügst du das Element ein (ok, das Einfügen fehlt noch, aber du setzt size hoch...)

Das ist aber doch nicht das, was du machen willst nehme ich an...
 
K

kneitzel

Gast
Du hast den Node p - da steckt doch auch ein Name drin. Vergleich den doch mit der übergebenen Person.
 

MoxxiManagarm

Top Contributor
Bei Verketteten Listen stell dir auch immer gerne die ganze Sache bildlich vor. Nehmen wir einen Zug. Deine PhoneBookList ist das Führerhaus. Dieses Führerhaus kennt nur den ersten Waggon, also der, der an dieses Führerhaus gekoppelt ist (bei dir head). Jeder Waggon hat eine numerischen Wert (bei dir Person) und kennt wiederum den nächsten angekoppelten Waggon (next). Außerdem hast du einen Bahnmitarbeiter, er weiß stets vor welchem Waggon er steht. Nennen wir diesen einmal current. Der Bahnmitarbeiter fängt immer am Führerhaus an, wenn er etwas mit diesen aneinandergekoppelten Waggons tun soll.

Nehmen wir nun also das Beispiel Einfügen. current ist noch null, weil der Bahnmitarbeiter vor dem Führerhaus steht. Außerdem steht ein Waggon (new Node) auf einem anderen Gleis, der numerisch sortiert reingekoppelt werden soll. Der Bahnmitarbeiter geht zum ersten Waggon und schaut sich diesen an und schreitet so Waggon bis Waggon vor (current verändert sich), bis er zwischen einem Waggon mit niedrigerer Nummer und einem Waggon mit höherer Nummer steht. Diese 2 Waggons entkoppelt der Bahnmitarbeiter und koppelt diese stattdessen mit dem Waggon auf dem anderen Gleis. Es sind also 2 Kupplungen zu verändern.

Vielleicht hast du ja auch irgendwo Spielzeug o.Ä. rumliegen, mit welchem du das auf dem Tisch nachspielen kannst.
 

arhzz

Bekanntes Mitglied
Also ich würde dir raten erst einmal den Algorithmus in Worte zu fassen, damit die Hürde der Programmiersprache entfällt.

Deine while Schleife geht so lange weiter, wie der Vergleich 0 (Elemente sind gleich, wobei du noch nicht das aktuelle Element mit dem einzufügenden vergleichst) ergibt. So die Elemente nicht gleich sind, fügst du das Element ein (ok, das Einfügen fehlt noch, aber du setzt size hoch...)

Das ist aber doch nicht das, was du machen willst nehme ich an...
Na ja ich will di
Du hast den Node p - da steckt doch auch ein Name drin. Vergleich den doch mit der übergebenen Person.
Oooooooo ja dass habe ich voll übersehen, und ein Re auf deine vorhergire Post,wie vergleiche ich nicht das einzufügenden element nicht? Sollte dass nicht das compareTo machen? Und das Einfügen fehlt noch?Also habe ich dass element nicht in der liste eingefügen? Sollte dass nicht der teil mit dem Node n = new node sein?
 

arhzz

Bekanntes Mitglied
Bei Verketteten Listen stell dir auch immer gerne die ganze Sache bildlich vor. Nehmen wir einen Zug. Deine PhoneBookList ist das Führerhaus. Dieses Führerhaus kennt nur den ersten Waggon, also der, der an dieses Führerhaus gekoppelt ist (bei dir head). Jeder Waggon hat eine numerischen Wert (bei dir Person) und kennt wiederum den nächsten angekoppelten Waggon (next). Außerdem hast du einen Bahnmitarbeiter, er weiß stets vor welchem Waggon er steht. Nennen wir diesen einmal current. Der Bahnmitarbeiter fängt immer am Führerhaus an, wenn er etwas mit diesen aneinandergekoppelten Waggons tun soll.

Nehmen wir nun also das Beispiel Einfügen. current ist noch null, weil der Bahnmitarbeiter vor dem Führerhaus steht. Außerdem steht ein Waggon (new Node) auf einem anderen Gleis, der numerisch sortiert reingekoppelt werden soll. Der Bahnmitarbeiter geht zum ersten Waggon und schaut sich diesen an und schreitet so Waggon bis Waggon vor (current verändert sich), bis er zwischen einem Waggon mit niedrigerer Nummer und einem Waggon mit höherer Nummer steht. Diese 2 Waggons entkoppelt der Bahnmitarbeiter und koppelt diese stattdessen mit dem Waggon auf dem anderen Gleis. Es sind also 2 Kupplungen zu verändern.

Vielleicht hast du ja auch irgendwo Spielzeug o.Ä. rumliegen, mit welchem du das auf dem Tisch nachspielen kannst.
Okay,ich muss mir das zeichen oder so etwas vielleciht werde ich es besser verstehen.
 

MoxxiManagarm

Top Contributor
Ich habe dir für mein Beispiel mal ein Codebeispiel zusammengeschraubt. Ich hoffe du kannst es daran nachvollziehen. Wenn du verkettete Listen einmal verstanden hast ist es leicht.

Java:
public class Zughaus {
    WaggonNode head;

    public void einreihen(int id) {
        WaggonNode waggon = new WaggonNode(id); // der Waggon auf dem anderen Gleis

        if (head == null) { // der Zug hat noch keinen Waggon
            head = waggon;
        } else if (head.id > id) { // muss zwischen Zughaus und erstem Waggon eingekoppelt werden
            waggon.next = head;
            head = waggon;
        } else {
            WaggonNode current = head;

            // so lange fortschreiten, bis der nächste Waggon eine höhere Nummer hat
            // oder der Bahnmitarbeiter das Ende erreicht hat
            while (current.next != null && current.next.id < id) {
                current = current.next;
            }

            // der Bahnitarbeiter steht nun vor dem Waggon, an welchem der neue Waggon angekoppelt werden soll
            // und führt die Kopplung durch
            waggon.next = current.next;
            current.next = waggon;
        }
    }

    public void ablaufen() {
        WaggonNode current = head;

        while (current != null) {
            System.out.println(current.id);
            current = current.next;
        }
    }

    public static void main(String... args) {
        Zughaus zug = new Zughaus();

        zug.einreihen(8);
        zug.einreihen(5);
        zug.einreihen(7);
        zug.einreihen(2);
        zug.einreihen(1);

        zug.ablaufen();
    }
}

class WaggonNode {
    int id;
    WaggonNode next;

    public WaggonNode(int id) {
        this.id = id;
    }
}

Ausgabe:
Code:
1
2
5
7
8
 

arhzz

Bekanntes Mitglied
Ich habe dir für mein Beispiel mal ein Codebeispiel zusammengeschraubt. Ich hoffe du kannst es daran nachvollziehen. Wenn du verkettete Listen einmal verstanden hast ist es leicht.

Danke dir viel! Also ich habe auch etwas probiert mit hilfe von google,etwas änlicher zu meinem Beispiel;

Java:
final class TaskList {

  Node head = null;

  void insert(Task task, java.util.Comparator comparator) {
    Node p = head, prev = null;

    while (p != null) {
      int comparison = comparator.compare(task, p.task);

      if (comparison == 0) return;
      if (comparison < 0) break;

      prev = p;
      p = p.next;
    }

    Node n = new Node(task);

    if (prev == null) {
      // p must be head in this case
      assert p == head;

      if (p == null) {
        // insert in empty list
        head = n;
      } else {
        // insert before first element in list
        head = n;
        n.next = p;
      }
    } else {
      if (p == null) {
        // insert after last element
        prev.next = n;
      } else {
        // insert before p, somewhere in the middle
        prev.next = n;
        n.next = p;
      }
    }



Der unterschied sind die methode compareTo (Die ich noch nicht weiss wie ich sie implementieren soll) und der Rückgabetyp.Es ist void und es sollte boolean sein. Jetzt ist nun die frage wie ich diese 2 Dinge in diesen Code implementiere[/codE]
 

MoxxiManagarm

Top Contributor
compareTo kommt dorthin wo ich mit > bzw < die id vergleiche. Bei boolean kommt es darauf an was er bedeudet. Ich nehme mal an es soll false zurückgeliefert werden, falls der Name schon existiert?
 

arhzz

Bekanntes Mitglied
Java:
final class TaskList {

  Node head = null;

  void insert(Task task, java.util.Comparator comparator) {
    Node p = head, prev = null;

    while (p != null) {
      int comparison = comparator.compare(task, p.task);

      if (comparison == 0) return;
      if (comparison < 0) break;

      prev = p;
      p = p.next;
    }

    Node n = new Node(task);

    if (prev == null) {
      assert p == head;
      if (p == null) {  
        head = n;
      } else {
        head = n;
        n.next = p;
      }
    } else {
      if (p == null) {
       
        prev.next = n;
      } else {
   
        prev.next = n;
        n.next = p;
      }
    }
compareTo kommt dorthin wo ich mit > bzw < die id vergleiche. Bei boolean kommt es darauf an was er bedeudet. Ich nehme mal an es soll false zurückgeliefert werden, falls der Name schon existiert?
Ja,genau dass.
 

MoxxiManagarm

Top Contributor
Ok, abgeändertes Beispiel (ich habe die Kommentare nun rausgelassen):

Java:
public class Zughaus {
    WaggonNode head;

    public boolean einreihen(int id) {
        WaggonNode waggon = new WaggonNode(id);

        if (head == null) {
            head = waggon;
            return true;
        }

        if (id < head.id) {
            waggon.next = head;
            head = waggon;
            return true;
        }

        if (id == head.id) {
            return false;
        }

        WaggonNode current = head;
        while (current.next != null && current.next.id < id) {
            current = current.next;
        }

        if (current.next != null && current.next.id == id) {
            return false;
        }

        waggon.next = current.next;
        current.next = waggon;
        return true;
    }

    public void ablaufen() {
        WaggonNode current = head;

        while (current != null) {
            System.out.println(current.id);
            current = current.next;
        }
    }

    public static void main(String... args) {
        Zughaus zug = new Zughaus();

        for (int iter : new int[]{8, 5, 7, 2, 1, 8, 1}) {
            if (!zug.einreihen(iter)) {
                System.out.println(iter + " konnte nicht eingekoppelt werden!");
            }
        }

        zug.ablaufen();
    }
}

class WaggonNode {
    int id;
    WaggonNode next;

    public WaggonNode(int id) {
        this.id = id;
    }
}

Ausgabe

Code:
8 konnte nicht eingekoppelt werden!
1 konnte nicht eingekoppelt werden!

1
2
5
7
8
 

arhzz

Bekanntes Mitglied
Ok, abgeändertes Beispiel (ich habe die Kommentare nun rausgelassen):

Java:
public class Zughaus {
    WaggonNode head;

    public boolean einreihen(int id) {
        WaggonNode waggon = new WaggonNode(id);

        if (head == null) {
            head = waggon;
            return true;
        }

        if (id < head.id) {
            waggon.next = head;
            head = waggon;
            return true;
        }

        if (id == head.id) {
            return false;
        }

        WaggonNode current = head;
        while (current.next != null && current.next.id < id) {
            current = current.next;
        }

        if (current.next != null && current.next.id == id) {
            return false;
        }

        waggon.next = current.next;
        current.next = waggon;
        return true;
    }

    public void ablaufen() {
        WaggonNode current = head;

        while (current != null) {
            System.out.println(current.id);
            current = current.next;
        }
    }

    public static void main(String... args) {
        Zughaus zug = new Zughaus();

        for (int iter : new int[]{8, 5, 7, 2, 1, 8, 1}) {
            if (!zug.einreihen(iter)) {
                System.out.println(iter + " konnte nicht eingekoppelt werden!");
            }
        }

        zug.ablaufen();
    }
}

class WaggonNode {
    int id;
    WaggonNode next;

    public WaggonNode(int id) {
        this.id = id;
    }
}

Ausgabe

Code:
8 konnte nicht eingekoppelt werden!
1 konnte nicht eingekoppelt werden!

1
2
5
7
8

Okay, ich habe probiert Analog zu deinen Beispiel meinen zu implementieren.

Java:
class PhoneBookList implements PhoneBook {
    private int size = 0;
    Node head;
    
    private static final class Node { //class Wagonnode
        final Person person;
        Node next;
        
        Node(Person person) {
            this.person = person;
        }
    }
    
    public boolean insert(Person person) {
        Node n = new Node(person); //die Person die sagen wir vor der Tür steht.
        Node p = head,prev = null;// den Head auf p zuweisen.
        
        
        if(p == null) {//Niemand ist in dem raum
            head = n;//also soll die neu Person die erste sein die rein geht.
            return true;
        }
        
        int comparison = p.name.compareTo(n.name);//den Namen von der ersten person mit dem Namen der neuen person vergleichen.
        
        if(comparison < 0) {
            n.next = p;
            p = n;
            size++;// den wert size um 1 zu erhohen, brauche ich dass überhaupt?
            return true;
        }
        
        if(comparison == 0) {
            return false;
            
        }
        
        Node current = p;
        while(current.next !=null && current.next.person < person) {
            current = current.next;
        }
        if(current.next !=null && current.next.person == person) {
            return false;
            
        }
    
        n.next = current.next;
        current.next = n;
        return true;
    }
 

MoxxiManagarm

Top Contributor
Was mir spontan auffällt: wenn du size brauchst, dann müsst du es auch überall dort erhöhen, wo du die zurückliefert. Aktuell machst du das nur an einer stelle
 

mihe7

Top Contributor
Das bedeutet, dass es nicht möglich ist, zwei Objekte mit < zu vergleichen. S. zum Beispiel Kommentar #25 und #28.
 

arhzz

Bekanntes Mitglied
Ich denke ich hab es geschafft

Java:
class PhoneBookList implements PhoneBook {
    private int size = 0;
    Node head = null;

    private static final class Node {
        final Person person;
        Node next;

        Node(Person person) {
            this.person = person;
        }
    }

    public boolean insert(Person person) {
        Node n = new Node(person);
        Node p = head;

        if(p == null) {
            head = n;
            size++;
            return true;
        } else {

            Node temp = p;
            int comparison;
            while(temp.next != null) {
                comparison = temp.person.name.compareTo(person.name);
                if(comparison == 0){
                    return false;
                }
                temp = temp.next;
            }
            temp.next = n;
            size++;
            return true;
        }

    }
}
 
K

kneitzel

Gast
Wenn die Liste sortiert sein soll, dann wird diese Anforderung noch nicht erfüllt. Derzeit fügst Du neue Elemente nur am Ende ein.
 
K

kneitzel

Gast
Ich empfehle wirklich, das einmal durchzuspielen.

Wenn Du die Liste hast aus:
Anton
Berta
Zeppelin

Und du sollst Martha hinzu fügen:
Wie lange gehst du die Liste durch? Was prüft du beim durchgehen?
 

MoxxiManagarm

Top Contributor
Nein, du musst so lange durchgehen bis du die Stelle gefunden hast, welche ein kleineres und ein größeres Element trennt. Dazwischen fügst du das neue Element ein.
 

arhzz

Bekanntes Mitglied
Nein, du musst so lange durchgehen bis du die Stelle gefunden hast, welche ein kleineres und ein größeres Element trennt. Dazwischen fügst du das neue Element ein.
Okay also muss ich meine while schleife anpassen? Meine schleife sagt gehe bis zum ende,und sie soll sagen gehe bis zum ende oder bis zu der Stelle welche ein kleiners und ein größeres element trennt?
 

MoxxiManagarm

Top Contributor
Du kannst dir doch mein Beispiel nochmal vor Augen halten. Dort gehe ich so lange mit dem Bahnarbeiter vorwärts, bis die id von next größer ist als die id vom einzufügenden Waggon. Das resultiert darin, dass der Bahnmitarbeiter immer vor einem Waggon (current) steht mit einer kleineren id. D.h. current ist das kleinere Element und current.next das größere Element. Und genau dazwischen kommt der neue Waggon.
 

arhzz

Bekanntes Mitglied
Du kannst dir doch mein Beispiel nochmal vor Augen halten. Dort gehe ich so lange mit dem Bahnarbeiter vorwärts, bis die id von next größer ist als die id vom einzufügenden Waggon. Das resultiert darin, dass der Bahnmitarbeiter immer vor einem Waggon (current) steht mit einer kleineren id. D.h. current ist das kleinere Element und current.next das größere Element. Und genau dazwischen kommt der neue Waggon.
Ok ich werde versuchen zu anpassen. Danke dir!
 

arhzz

Bekanntes Mitglied
Soll die verkettete Liste eigentlich immer sortiert sein? Ich weiß nich was ihr so lange daran rumdoktort...
Ja sie soll immer sortiert sein.Ich denke ich habe es auch geshaft;

EDIT:

Java:
public boolean insert(Person person) {

        Node newNode = new Node(person);

        if (head == null) {
            head = newNode;
            size++;
            return true;
        }

        Node current = head;
        Node prev = null;
        int comparison;

        while (current != null) {
            comparison = person.name.compareTo(current.person.name);
            if (comparison == 0) {
                return false;
            } else if (comparison > 0) { /// greater than

                if (current.next == null) { // check if reach tail of the linked list add and break
                    current.next = newNode;
                    break;
                }
                current = current.next;
            } else { // less then
                if (prev == null) { // check if it should be first then put and break
                    Node oldHead = head;
                    head = newNode;
                    head.next = oldHead;
                    break;
                }
                prev.next = newNode;
                newNode.next = current;
                break;
            }
            prev = current;
            current = current.next;
        }
        size++;
        return true;
    }

Hab code vergessen lol
 
Zuletzt bearbeitet:

temi

Top Contributor
Das sieht mir von irgendwoher zusammenkopiert aus und bei der Funktionalität wäre ich mir auch nicht so sicher...
 
K

kneitzel

Gast
Also ich würde den Algorithmus in Worten so aufbauen:
1. Liste leer? -> Leere Liste abhandeln
2. aktuelles Element ist erstes Element
3. So lange wie aktuelles Element ein Nachfolger hat und der Nachfolger vor dem einzufügenden Element kommen soll -> Ein Element weiter gehen.
3. Neues Element erstellen mit einzufügendem Wert und Nachfolger = Nachfoler vom aktuellem Element
4. Nachfolger vom aktuellen Element ist das neue Element.

Also relativ einfach und logisch aufgebaut. Relativ wenig Prüfungen. Die Schleife (3. bei mir) umfasst nur einen Befehl ...
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
K Warum ist die binäre Suche bei der verketteten Liste nicht so effektiv? Java Basics - Anfänger-Themen 3
T Collections Erstellung eines Listeneintrags einer verketteten Liste Java Basics - Anfänger-Themen 5
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
1 Wie addiert man die Elemente einer Verketteten Liste? Java Basics - Anfänger-Themen 5
B Methoden Traverse Methode bei verketteten Listen Java Basics - Anfänger-Themen 3
L rückwärtsausgeben einer doppelt verketteten 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
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
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
llabusch Verkette Listen - Einfach und Doppelt Java Basics - Anfänger-Themen 3
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
S Erfahrungswerte von schnelles durchlaufen von Listen mit 2 Werten Java Basics - Anfänger-Themen 10
Joew0815 Problem mit Listen: add() Java Basics - Anfänger-Themen 11
P Zeichenorientierte & Serialisierte Datenverarbeitung Listen Java Basics - Anfänger-Themen 8
E Listen und Generics Java Basics - Anfänger-Themen 9
L dynamisches erzeugen von array Listen Java Basics - Anfänger-Themen 7
E Listen und Duplikate Java Basics - Anfänger-Themen 2
R Hilfe bei Listen Java Basics - Anfänger-Themen 10
F Collections Liste von Listen Java Basics - Anfänger-Themen 21
A Methoden Anfängerfrage: 2 Listen Vergleichen Java Basics - Anfänger-Themen 7

Ähnliche Java Themen

Neue Themen


Oben