Suchalgorythmus für Musik-Liste


#1
Moin leutes!
Ich bin gerade am Programmieren von einem kleinen Listenprogramm welches Musik speichern soll.

Folgende Codes:
(Allgemein für die Liste)
Code:
public class List<ContentType> {

  /* --------- Anfang der privaten inneren Klasse -------------- */

  private class ListNode {

    private ContentType contentObject;
    private ListNode next;

    private ListNode(ContentType pContent) {
      contentObject = pContent;
      next = null;
    }
    public ContentType getContentObject() {
      return contentObject;
    }
    public void setContentObject(ContentType pContent) {
      contentObject = pContent;
    }

 
    public ListNode getNextNode() {
      return this.next;
    }
    public void setNextNode(ListNode pNext) {
      this.next = pNext;
    }

  }

  /* ----------- Ende der privaten inneren Klasse -------------- */

  // erstes Element der Liste
  ListNode first;

  // letztes Element der Liste
  ListNode last;

  // aktuelles Element der Liste
  ListNode current;

 
  public List() {
    first = null;
    last = null;
    current = null;
  }
  public boolean isEmpty() {
    // Die Liste ist leer, wenn es kein erstes Element gibt.
    return first == null;
  }

  public boolean hasAccess() {
    // Es gibt keinen Zugriff, wenn current auf kein Element verweist.
    return current != null;
  }

  public void next() {
    if (this.hasAccess()) {
      current = current.getNextNode();
    }
  }

  public void toFirst() {
    if (!isEmpty()) {
      current = first;
    }
  }
  public void toLast() {
    if (!isEmpty()) {
      current = last;
    }
  }

  public ContentType getContent() {
    if (this.hasAccess()) {
      return current.getContentObject();
    } else {
      return null;
    }
  }

  public void setContent(ContentType pContent) {
    // Nichts tun, wenn es keinen Inhalt oder kein aktuelles Element gibt.
    if (pContent != null && this.hasAccess()) {
      current.setContentObject(pContent);
    }
  }

  public void insert(ContentType pContent) {
    if (pContent != null) { // Nichts tun, wenn es keinen Inhalt gibt.
      if (this.hasAccess()) { // Fall: Es gibt ein aktuelles Element.

        // Neuen Knoten erstellen.
        ListNode newNode = new ListNode(pContent);

        if (current != first) { // Fall: Nicht an erster Stelle einfuegen.
          ListNode previous = this.getPrevious(current);
          newNode.setNextNode(previous.getNextNode());
          previous.setNextNode(newNode);
        } else { // Fall: An erster Stelle einfuegen.
          newNode.setNextNode(first);
          first = newNode;
        }

      } else { //Fall: Es gibt kein aktuelles Element.

        if (this.isEmpty()) { // Fall: In leere Liste einfuegen.

          // Neuen Knoten erstellen.
          ListNode newNode = new ListNode(pContent);

          first = newNode;
          last = newNode;
        }

      }
    }
  }
  public void append(ContentType pContent) {
    if (pContent != null) { // Nichts tun, wenn es keine Inhalt gibt.

      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
        this.insert(pContent);
      } else { // Fall: An nicht-leere Liste anfuegen.

        // Neuen Knoten erstellen.
        ListNode newNode = new ListNode(pContent);

        last.setNextNode(newNode);
        last = newNode; // Letzten Knoten aktualisieren.
      }

    }
  }
  public void concat(List<ContentType> pList) {
    if (pList != this && pList != null && !pList.isEmpty()) { // Nichts tun,
    // wenn pList und this identisch, pList leer oder nicht existent.

      if (this.isEmpty()) { // Fall: An leere Liste anfuegen.
        this.first = pList.first;
        this.last = pList.last;
      } else { // Fall: An nicht-leere Liste anfuegen.
        this.last.setNextNode(pList.first);
        this.last = pList.last;
      }

      // Liste pList loeschen.
      pList.first = null;
      pList.last = null;
      pList.current = null;
    }
  }
  public void remove() {
    // Nichts tun, wenn es kein aktuelle Element gibt oder die Liste leer ist.
    if (this.hasAccess() && !this.isEmpty()) {

      if (current == first) {
        first = first.getNextNode();
      } else {
        ListNode previous = this.getPrevious(current);
        if (current == last) {
          last = previous;
        }
        previous.setNextNode(current.getNextNode());
      }

      ListNode temp = current.getNextNode();
      current.setContentObject(null);
      current.setNextNode(null);
      current = temp;

      //Beim loeschen des letzten Elements last auf null setzen.
      if (this.isEmpty()) {
        last = null;
      }
    }
  }
  private ListNode getPrevious(ListNode pNode) {
    if (pNode != null && pNode != first && !this.isEmpty()) {
      ListNode temp = first;
      while (temp != null && temp.getNextNode() != pNode) {
        temp = temp.getNextNode();
      }
      return temp;
    } else {
      return null;
    }
  }
 
}
Konstruktor für die Musiktitel
Code:
public class Musiktitel {

   String Titel;
   String Interpret;
   String Genre;
   int Titelnummer;
   
   Musiktitel(String Titel, String Interpret, String Genre, int Titelnummer) {
       
       this.Titel=Titel;
       this.Interpret=Interpret;
       this.Genre=Genre;
       this.Titelnummer=Titelnummer;
   
   public String getMusiktitel() {
       return (Titel + " , " +  Interpret +". " + " , " +  Genre + " ,  " +  Titelnummer );
   }
}
Das Verwaltungsprogramm
Code:
public class Musikverwaltungsprogramm {

   public static void main(String[] args) {
       // TODO Auto-generated method stub

       List<Musiktitel> Musikliste = new List<Musiktitel>();
       
       Musiktitel T1 = new Musiktitel("War Pigs ","Black Sabbath", "Heavy Metal", 1);
       Musiktitel T2 = new Musiktitel("Black Dog ","Led Zepplin", "Heavy Metal", 2);
       Musiktitel T3 = new Musiktitel("Thunderstruck " ,"ACDC", "Heavy Metal", 3);
       Musiktitel T4 = new Musiktitel("Detroid Rock City " ,"Kiss", "Heavy Metal", 4);
       
       Musikliste.append(T1);
       Musikliste.append(T2);
       Musikliste.append(T3);
       Musikliste.append(T4);
       Musikliste.toFirst();
       
       
       public boolean lineareSuche(int i) {
           boolean gefunden = false;
           Musikliste.toFirst();
           while(Musikliste.hasAccess() && gefunden == false) {
               if (Musikliste.getContent() ==1) {
                   gefunden = true;
               }
               Musikliste.next();
           }
           return gefunden;
 }
         }
}
Jeder Musiktitel hat eine Nummer hinten, die man im endefekt mitbdem Suchalgorythmus sucht.
Jedoch funktioniert der Suchalgorythmus (hier lineareSuche) nicht. (Musikliste unterstrichen)

Hoffe ihr könnt mir helfen :D
LG Max
 

HonniCilest

Erfahrenes Mitglied
#2
Grundsätzlich wären mehr Infos hilfreich bei der Aussage "funktioniert nicht".
Aber, beim groben überfliegen Fallen mir mehrere Sachen auf die ich anmerken möchte:

- Musikverwaltungsprogramm/Zeile24: Was bedeudet der Vergleich auf 1? Du vergleichst hier "ContentType" mit einer Zahl. Du gibst der Suche einen int i mit, aber verwendest i nirgends.
- In deiner List Implementierung verwendest du an mehreren Stellen den Vergleichsoperator für Objekte. Objekte möglichst immer mit equals vergleichen.
- In einer einfach verketteten Liste eine previous Methode zu implementieren - warum? Wenn du ein previous haben möchtest dann greif doch bitte zu einer doppelt verketteten Liste.
- getMusiktitel: Würde ich eher als überschriebene toString Methode implementieren
 
#3
Der Code ist jetzt ein kleines bisschen verändert worden. Zwei Fehler bleiben jedoch...
Code:
public class Musikverwaltungsprogramm {

public static void main(String[] args) {
   // TODO Auto-generated method stub

   List<Musiktitel> Musikliste = new List<Musiktitel>();
   
   Musiktitel T1 = new Musiktitel("War Pigs ","Black Sabbath", "Heavy Metal", 1);
   Musiktitel T2 = new Musiktitel("Black Dog ","Led Zepplin", "Heavy Metal", 2);
   Musiktitel T3 = new Musiktitel("Thunderstruck " ,"ACDC", "Heavy Metal", 3);
   Musiktitel T4 = new Musiktitel("Detroid Rock City " ,"Kiss", "Heavy Metal", 4);
   
   Musikliste.append(T1);
   Musikliste.append(T2);
   Musikliste.append(T3);
   Musikliste.append(T4);
   Musikliste.toFirst();

boolean gefunden=false;
int i=0;
int n = 2;
while(i<4 && gefunden==false) {
   if (Musikliste[i]==n) {
       System.out.println(i) ;
       gefunden =true;
   }
   i++;
} 
}
}
1.) Bei der while-Schleife musste ich jetzt <4 hinschreiben, weil Musikliste.size rot markiert wurde.

2.) Musikliste wird ebenfalls rot unterstrichen, weil mein i in einem Array [] ist. Wie könnte ihc das umschreiben?

Hoffe ihr könnt mir helfen :D VG Max
 

HonniCilest

Erfahrenes Mitglied
#4
Mit Zeile 23 vergleichst du aber weiterhin einen Musiktitel mit einem int. Wenn dann müsste es etwa so aussehen würde ich meinen:
Java:
Musikliste[i].getTitelnummer()==n
Aber Musikliste ist doch garkein Array, oder? Also warum ein Array-Index. Bei einer Suche in einer Liste hängelst du dich normalerweise durch die Liste nach dem Schema:
Java:
while(list.hasNext()) {
 Musiktitel element = list.next();
// do something with element
}
Musikliste.size wurde bei dir sicherlich rot markiert, weil du das nicht implementiert hast oder ist deine Liste nicht mehr deine eigene Implementierung