✔ Suchalgorythmus für Musik-Liste

L

LegendaryBeazt

Mitglied
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
 
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
 
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
 
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
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück