Eigenen Abstrakten Datentypen

[Spin]

Hallo

Ich möchte eine eigen TVListe bauen aber irgendwie komme ich nicht weiter. Dazu möchte ich keine Liste aus der Java Api nehmen sonder eine eigene programmieren , der man etwas hinzufügen kann ..usw.

    /* Einfügen in die Liste */
    public void add(TvShow t) {
       if(elementCount==0) {// wenn es noch kein Element in der Liste gibt
       head = new TvShowListElement(t);
       elementCount++;
       }
       else if(elementCount>0){ //Gibt es schon ein erstes Element gehe alle Elemente durch
            //und finde das letzte -> (das Element bei welchem die Bedingung current.next ==null
            //erfüllt ist.
           head = new TvShowListElement(t);
           TvShowListElement current = head;
            while (current.getNext() != null) {
                    current = current.getNext();
                }
            head = current.getNext();
            elementCount++;
       }
       }

Es will nicht.
Ich überspeicher immer mein erstes Element :/

head = current.getNext();

Der teil müsste so sein :

current.getNext() =head;

Aber so will das meine IDE nicht :/
Hat einer einen Tip für mich ?

 

[sambalmueslie]

Ich blick noch nciht ganz, was du willst .. aber könnte ein Setter für das "next" element die richtige Wahl sein ???

current.setNext(head);

 

[ModellbahnerTT]

Klar überspeicherst du immer dein erstes Element, steht ja auch so in deinem Quelltext:
head = new TvShowListElement(t);
der Code danach ist so im Moment irrelevant...

 

[sambalmueslie]

Klar überspeicherst du immer dein erstes Element, steht ja auch so in deinem Quelltext:
head = new TvShowListElement(t);
der Code danach ist so im Moment irrelevant...

Nee nee ich würde mal behaupten, das passt noch

er möchte ja dieses "head" Element als letztes Element in der Liste anhängen und dafür wird es erstellt..

nur bei

TvShowListElement current = head;

müsste er sich das erste Element der Liste besorgen, würde ich mal sagen

Gruß Oli

 

[Spin]

 /* Einfügen in die Liste */
    public void add(TvShow t) {
       if(elementCount==0) {// wenn es noch kein Element in der Liste gibt
       head = new TvShowListElement(t);
       elementCount++;
       }
       else if(elementCount>0){

           // Nach Nachfolger
           TvShowListElement temp = head.getNext();
           TvShowListElement current = temp;
           current = new  TvShowListElement(t);
           current.setNext(temp);
           elementCount++;
           

           
       }
       }

 public static void main(String[]args){

        TvShow a = new TvShow("hansa", 30);
        TvShow b = new TvShow("lola", 30);
        TvShowList<TvShow> tvList = new TvShowList<TvShow>();

        tvList.add(a);
        tvList.add(b);

        for(int i=0;i<tvList.getSize();i++){
            System.out.println(tvList);
        }

        /*Ausgabe*/

    }

Der haut mir immer noch die beiden gleichen Objekte raus...why?

Ich habe mir überlegt:
Ich erstelle eine temporäres Listenelement. Das ist das Element welches dem head-Element folgt.
Dann erzeuge ich neues elment was den zeiger auf das temporäre hat.
der zeiger wird mit daten gefüllt und ist somt nicht mehr null und folgt dem head element,
und ich setze meine temporäre variable auf das nächste element. Da später das geiche spiel.

Damit ich weiß was da ist , lass ich 1 hochzählen.

Das will aber nicht , liegts an meiner ausgabe?

danke

 

[sambalmueslie]

Hm, also das ist jetzt falscher als das vorhin

für das hinzufügen (wenn schon elemente drinne sind)

1) Head-Element der Liste (das ist das erste Element) nehmen
2) So lange getNext() bis das Ende der Liste erreicht ist.
3) An das letzte Element mit setNext() das neue Element anhängen.

Thats it

Gruß Oli

 

[ModellbahnerTT]

1. deine Ausgabe ist falsch, du gibst in der Schleife nur deine Liste aus... (davon abgesehen ist Indexbasierter Zugriff bei Verketteten Listen ungünstig).
2. dein neuer Code ist noch kälter von der Lösung als dein Erster Code, versteh nicht was da gemacht werden soll: Die temp Variable hängt dort in der Luft, dann wird dem neuen Listeneintrag der aktuell Zweite Listeneintrag als next gesetzt (was voraussetzt, dass überhaupt schonmal 2 Einträge in der Liste sind - ganz unmöglich im Moment - , sonst null), das wars, nach der Methode ist das neue Element wieder verloren.

Schreib dir doch erstmal in Deutsch auf was der Code überhaupt machen soll, bevor du versuchst ihn in Javaform zu bringen.

 

[ModellbahnerTT]

Nee nee ich würde mal behaupten, das passt noch

er möchte ja dieses "head" Element als letztes Element in der Liste anhängen und dafür wird es erstellt..

Ne, er überschreibt zu Anfang das head Element seiner Liste, damit hat er die Listenstruktur schon kaputt gemacht, der Code der folgt hat keinen Effekt mehr (sogar wenn er korrekt wär )

 

[sambalmueslie]

Ne, er überschreibt zu Anfang das head Element seiner Liste, damit hat er die Listenstruktur schon kaputt gemacht, der Code der folgt hat keinen Effekt mehr (sogar wenn er korrekt wär )

Oki ich geb dir recht, er müsste da das neue Element erstellen, das angehängt wird

 

[Spin]

Kein Plan mehr , bekomme nicht mal mehr die Ausgabe in einer for schleife hin ...ach was solls , manchmal suckt java.

 

[sambalmueslie]

Try this

 public void add(TvShow t) {
       if(elementCount==0) {// wenn es noch kein Element in der Liste gibt
       head = new TvShowListElement(t);
       elementCount++;
       }
       else if(elementCount>0){ //Gibt es schon ein erstes Element gehe alle Elemente durch
            //und finde das letzte -> (das Element bei welchem die Bedingung current.next ==null
            //erfüllt ist.
           TvShowListElement newChild = new TvShowListElement(t);
           TvShowListElement current = head;
            while (current.getNext() != null) {
                    current = current.getNext();
                }
            current.setNext(newChild);
            elementCount++;
       }
       }

 

[Spin]

Danke dir

 public void add(TvShow t) {
       if(elementCount==0) {// wenn es noch kein Element in der Liste gibt
       head = new TvShowListElement(t);
       elementCount++;
       }
       else if(elementCount>0){

           TvShowListElement newChild = new TvShowListElement(t); // Listenelement mit Daten füllen
           TvShowListElement current = getHead(); // Daten von head nach current
            while (current.getNext() != null) { // solange der nächste von current nicht null
                    current = current.getNext(); // current wird das nächste element zugewiesen
                }

            current.setNext(newChild);
            newChild.setPrevious(current);
            elementCount++;
       }
       }

    public void dispay() {
        /* Ausgabe aller Elemente die in der Liste sind */
        System.out.println("Daten der Listenelemnte:" + getHead().getData());
        System.out.println("Daten der Listenelemnte:" + getHead().getNext().getData());
        System.out.println("Daten der Listenelemnte:" + getHead().getNext().getNext().getData());
        System.out.println("Daten der Listenelemnte:" + getHead().getNext().getNext().getPrevious().getPrevious().getData());
    }

Nun habe ich auch auf den davor verwiesen und ich kann so auf die Zugreifen , doch wie kann ich nun mit einer forschleife auf die Daten zugreifen?

 public static void main(String[]args){

        TvShow a = new TvShow("Billy Madison", 30);
        TvShow b = new TvShow("lola", 30);
        TvShow c = new TvShow("abla", 30);
        TvShowList<TvShow> tvList = new TvShowList<TvShow>();

        tvList.add(a);
        tvList.add(b);
        tvList.add(c);


       
        tvList.dispay();

        for(int i=0;i<=tvList.getSize();i++){
            System.out.println(tvList.getHead().getData());
        }

        /*Ausgabe*/

    }

Mit der Anweisung gibt er mir leider nur head aus und das 4 mal. Er soll aber immer auf den nächsten verweisen.

1. getHead()
2. getHead(),getNext().


usw.

Später soll die liste auch entfernen und an einen Index hinzufügen usw. können ...ohje .

danke

 

[sambalmueslie]

Da brauchst für deine Liste einen Iterator.
guck mal hier

http://www.java-forum.org/java-basics-anfaenger-themen/83263-eigener-iterator-fuer-linkedlist.html

Gruß Oli

 

[Spin]

 public void dispay() {
      TvShowListElement lauf = head;
       while (lauf != null) {
            System.out.print(lauf.getData()+ ", ");
            lauf = lauf.getNext();
        }
        System.out.println();
    }

Ne , ich will keinen eigenen Iterator.
Das muss nicht sein , habe es jetzt so hinbekommen.

Ich bin dir sehr dankbar Oli , doch bräuchte ich mehr Kopfarbeit.
Damit meine ich, dass es schön wäre, wenn du mir schreiben könntest, was du dir dabei denkst.

Zum Beispiel wenn es jetzt darum geht , in der Liste etwas zu entfernen.
Ich denke mir dabei , dass ich irgendwie auf den index zugreifen muss.

und dann sage : t = null;

 /* Element enfernen aus der Liste*/
    public void remove(TvShow t) {
        
        TvShowListElement data = new TvShowListElement(t); // Listenelement mit Daten erzeugen
        // Startelement in lauf speichern
        TvShowListElement lauf = getHead();
        
        while (lauf != null) // solange wie das erste element nicht null
         {
            if (data == lauf) { // wenn die Elemente die selben sind
                lauf = null; // soll lauf auf null und raus
            }
            lauf = lauf.getNext();
        }
    }

Oder so, brauch irgendwie tipps ...gedanklich, nicht in java

Danke dir

 

[sambalmueslie]

Also zum durchiterieren, das was du da tust, ist im endeffekt das selbe nur etwas komplizierter geschrieben

Ein Iterator ist eben ein gebräuchliches Konzept und klar erst mal bisschen kompliziert, aber wenn du es verstanden hast, dann ist es auch für andere einfacher. (Aber das kannst du wenn du magst, auch später noch ändern)

So jetzt zum entfernen:

Nehemen wir mal eine Liste mit 5 Elementen an:

A(Head) -- next -- > B -- next -- > C -- next -- > D -- next -- > E

So und wenn du jetzt das Element "C" entfernen möchtest, dann musst du folgenderamaßen vorgehen :

Bei B das next auf D setzten und C entfernen.
Da wir hier in Java sind, erledigt das für dich der Garbage Collector, außer jemand verwendet das Element noch.
Denke mal, es reicht einfach das Next umzuhängen.

Gruß Oli

 

[Spin]

 /* Element enfernen aus der Liste*/
    public void remove(TvShow t) {
        
        TvShowListElement newChild = new TvShowListElement(t); // Listenelement mit Daten erzeugen
        // Startelement in lauf speichern
        TvShowListElement current = getHead();  // Rolle eines Ankers
        System.out.println(current);
        while (current!= null) // In der  while-Schleife werden die Werte der Elemente in der Liste solange durchsucht,
                             //bis das letzte Listenelement erreicht ist, d.h. bis  naechstes auf null zeigt.
         {
            if (current == newChild) { // wenn beim Durchlauf, die gleichen Daten vorkommen:
                TvShowListElement prev = current.getPrevious();
                prev.setNext(current.getNext());

            }
            current = current.getNext();
           
        }
    }

Meinst du so?
Wie meinst du einfach nur anhängen?
Oder ist das viel zu kompliziert?

 

[sambalmueslie]

Nee nee so nicht..

ich meinte umhängen .. nicht anhängen

du musst in dem Beispiel das Element C entfernen.

Dafür muss jetzt das Element B auf Element D zeigen, wenn du getNext aufrufst.
Du musst also folgendes machen.

1) Das Element C suchen
2) Das Vorgänger - Element auf das Nachfolger-Element zeigen lassen (mit VorgängerElement.setNext(NachfolgerElement)
3) Das Element C löschen (entfällt bei JAVA)

Gruß Oli

 

[Spin]

 /* Element enfernen aus der Liste*/
    public void remove(TvShow t) {
         TvShowListElement data = new TvShowListElement(t); // Listenelement mit Daten erzeugen
        // Startelement in lauf speichern
        TvShowListElement current = getHead();  // Rolle eines Ankers



        for(int i=0; i<elementCount;i++){
            if (current.getData() == data.getData()){ // 1. Element suchen ( wird auch gefunden )
                // ich weiß hier einfach nicht weiter

                // wie kann ich hier nun von B an D hängen

                // wenn bsp.: C das gesuchte Element ist
                // soll das Element vor C , auf das Element nach C zeigen
                // Aber vor dem Element A gibts kein Element
                // Aber nach dem Element C gibts kein Element

                // mit getPrevious() bekomme ich den Vorgänger
                 // in current stecken die Daten von getHead();

                // wenn jetzt A das zu löschende Element ist ( also das gesuchte)
                // dann soll current, also A nicht mehr head sein sondern von getHead().getNext();
//                current = getHead().getNext();
                // nun ist in A nicht mehr A sondern  B; ( aber bisher nur im Zischenspeicher , aber noch nicht in der Liste)
                // und das an Position 0 oder?

//                setHead(current);

                // wenn wir nun B löschen wollen
                // in current ist nun C drin
                current = getHead().getNext();
                // in prev ist nun A drin
                TvShowListElement prev = getHead().getPrevious();
                prev.setNext(current);

                elementCount--; // wenn ein Element gefunden wurde, liste um 1 verkleinern


                
            }

            current = current.getNext();

        }

Ich glaub ich bin zu doof dazu, gehe aber jetzt schlafen .

Sollte ich lieber mit den Daten in den Elementen arbeiten?
Wie verweis ich auf den , ich will es wohl nicht verstehen -.-

plz help

 

[sambalmueslie]

na wir sind schon auf der richtigen Spur

probier mal das hier:

public void remove(TvShow t) {
         TvShowListElement data = new TvShowListElement(t); // Listenelement mit Daten erzeugen
        // Startelement in lauf speichern
        TvShowListElement current = getHead();  // Rolle eines Ankers
 
 
 
        for(int i=0; i<elementCount;i++){
            if (current.getData() == data.getData()){ 
                TvShowListElement next = current.getNext();
                if(i==0) // ist es das head element, das entfernt werden soll?
                {
                  next.setPrevious(null);
                  head = next;
                } else {
                  TvShowListElement prev = current.getPrevious();
                  prev.setNext(next);
                }
                elementCount--; // wenn ein Element gefunden wurde, liste um 1 verkleinern
                 
            }
 
            current = current.getNext();
 
        }

Testen darfst du es, ist einfach so runtergetippt
Gruß Oli

 

[Spin]

Man ey, wie machst du dass?

Programmierst du , weil dir es Spass macht oder weil du es beruflich musst, oder studierst du etwas in die richtung?

Bist ja auch ziemlich Forumaktiv , wie ich ^^.
Oki , ich danke dir vielmals .

Auf gehts zum nächsten Problem , mal schauen ob ich das hinbekomme.

Nämlich:

/* Einfügen in die Liste an einer bestimmten Position*/
    public void add(int index, TvShow t) {
    }

Aber ich will erst selbst 5h nachdenken und dann nach Hilfe betteln
Danke nochmal Oli.:toll::toll:

 

[sambalmueslie]

Man ey, wie machst du dass?

Programmierst du , weil dir es Spass macht oder weil du es beruflich musst, oder studierst du etwas in die richtung?

Ja weiß es Spaß macht, ja weil ich es beruflich mache, und ja weil ich es studiert habe

find ich gut, dass du dir erst mal selber den kopf zerbrichst.

Versuch dir das ganze vielleicht als Kette(oder Zug) vorzustellen und evtl. aufzumalen.
-> Was musst du tun, wenn du das Element(Waggon) einfügst ?
-> Welche Sonderfälle musst du beachten?(Lokomotive, Letzter Wagen)

Viel Erfolg
Gruß Oli

 

[Spin]

So, das mit dem einfügen und entfernen geht jetzt alles. Auch die indexbasierte Abfrage.

Nun habe ich aber noch das Problem, dass ich keine richtigen Sortieralgorithmus hinbekomme.

Ich habe 2 Sendungen hinzugefügt und die sollen anhand der Startzeit sortiert werden, zudem soll "ÜBERSCHNEIDEN" ausgegeben werden , wenn sie sich überschneiden.

Mein Ansatz:

Ich nimm eine forschleife und hole mir die Laufteit von dem ersten element. Zudem hole ich mir vom ersten element die Startzeit.

Um nun rechnen und vergleichen zu können wander ich die Stunde in Minuten um , indem ich * 60 rechne. Das Speicher ich.

Bsp.: Wenn meine Sendung 2Uhr beginnt = 120 minuten. Auf die Startzeit addier ich die laufzeit , bsp: 80 minuten

Dann : 120+80 = 200 min.
Meine andere Sendung fängt 3 uhr an = 180min.

if(200 min >180min)

Dann überschneiden sich die Filme.

Da ich nun zwei vorschleifen habe , vergleicht das erste element auch mit den anderen.
Also wenn ich 5 Filme habe kann es auch sein , dass die bedingung 5 mal anschlägt.

In der 2ten vorschleife werden auch von jeden Objekt die Startzeiten mit einander verglichen:

  /*Die Methode compareTo() der Klasse HMTime gibt die Differenz in Minuten
     zwischen den beiden Zeiten zurück*/
    public int compareTo(HMTime another) {
        int time = this.getHour() * 60 +this.getMinute();
        int atime = another.getHour()*60 + this.getMinute();

        // wenn time<atime -> negativer Wert
        //wenn time>atime ->positiver wert
        int differenz = time - atime;
        if(differenz<0){
            return -1;
        }
        if(differenz>0){
            return 1;
        }
        return 0;
    }

Ich speicher mir wieder alles zwischen und vergleiche jedesmal.
Komischerweise ist das: current.compareTo(next)==0 einmal der Fall.

Habt ihr einen Vorschlag , ie ich das vielleicht trennen könnte?
Das prüfen der Überschneidung und das sortieren.

Beim sortieren sollte ich dann wie beim bubblesort vorgehen?

public void sortList() {
        // vor dem hinzufügen sortieren nach Sendezeit
        int tempArray[] = new int[list.getSize()]; // Laufzeiten und Sendezeit in ein Array speichern?
        for (int i = 0; i < list.getSize(); i++) {
            int runTime = list.getTvShowAt(i).getRunTime(); // Von jeder Sendung die Laufzeit holen
            HMTime current = list.getTvShowAt(i).getAirTime(); // Von jeder Sendung die Startzeit holen

            int time = current.getHour()*60 + current.getMinute();
            int temp = time + runTime;

            for (int j = 1; j < list.getSize(); j++){
                HMTime next = list.getTvShowAt(j).getAirTime();
                int ntime = next.getHour()*60 + next.getMinute();

                if(temp>ntime){
                   System.out.println("***ACHTUNG ÜBERSCHNEIDUNG***");
                }

                if(current.compareTo(next) ==1){
                    // dann tauschen in der liste

                }
                if(current.compareTo(next)==0){
                    System.out.println("Beide Filme senden zu gleichen Zeit");
                }

            }
        }
    }
}

Danke für eure bemühungen. gruß spin

 

[sambalmueslie]

Also erst mal zum tauschen:

Das Tauschen von zwei Elementen am Beispiel eines Eisenbahnzuges

Lok -> Wagen A -> Wagen B -> Wagen C

Jetzt sollen Wagen A und Wagen B getauscht werden.

Wie musst du in den einzelnen Schritten vorgehen ??

1) Wagen B von Wagen A abkuppeln
2) Wagen A von Lok abkuppeln
3) Wagen B von Wagen C abkuppeln
4) Wagen B an Lok ankuppeln
5) Wagen A an Wagen B ankuppeln
6) Wagen C an Wagen A ankuppeln

Lok -> Wagen B -> Wagen C -> Wagen C

Versuch das mal auf die Liste zu übertragen.
Zu dem zweiten Teil mit dem "überschneiden" kommen wir dannach erst

Gruß Oli

 

[Spin]

Moin, mein sortieren sollte gehen , doch frage ich mich wie ich TVShows zwischen speicher.

 public void addShow(TvShow t) {
        // vor dem hinzufügen in die Liste nach Sendezeit sortieren
        // dazu alle TvShows in ein ObjektArray speichern

        // wie kann ich hier die größe des arrays ermitteln?
        // irgendwie muss ich fragen können, wieviele TvShows übergeben werden?

        TvShow tempArray[] = new TvShow[3]; // Arraygräße ist dabei auf max 100 gesetzt
        for (int i = 0; i < tempArray.length; i++) {
            tempArray[i] = t;
        }


        /*sortieren*/
        for (int i = 0; i < tempArray.length; i++) {
            for (int j = i + 1; j < tempArray.length - 1; j++) {

                // ersteinmal die Sendezeitenberechnen für jede TvShow
                HMTime current = tempArray[i].getAirTime();
                int time = current.getHour() * 60 + current.getMinute();
                /* und für die zeiwete Show*/
                HMTime next = tempArray[i].getAirTime();
                int ntime = next.getHour() * 60 + next.getMinute();


                if (time > ntime)
                {
                    TvShow temp = tempArray[i];
                    tempArray[i] = tempArray[j];
                    tempArray[j] = temp;                         
                }
            }
        }

        /* adden*/
         for (int i = 0; i < tempArray.length; i++) {
             TvShow temp = tempArray[i];
             list.add(temp);

        }


        
    }

Mein Problem ist , dass ich TvShows übergebe und möchte sie in der Methode halten bis alle übergeben sind.
Ich glaube das geht garnicht, weil sie local sin :/

Außer ich mach sie zu Klassenvariablen, richtig?

Wenn ich meinen quellcode in eine andere methode wie , sortList() machen würde, dann würde ich erst alles adden und danach sortieren.

Möchte aber das beim hinzufügen schon sortiert wird.!
hilfe

danke

 

[sambalmueslie]

Naja du könntest ja aus der Add-Methode heraus die Sort Methode aufrufen

oder du suchst dir für Add die passende Stelle heraus, vorrausgesetzt, dass die Liste sortiert ist, musst du nur so lange durch die Liste gehen bis du die passende Stelle gefunden hast und dann die neue TV-Show einfügen.

Das was du gerade n deiner "add" methode machst ist ganz ganz böse

und auch nciht sinn und zweck der übung

du hast eine Liste, dann kopierst du diese erst mal in ein array, und später alles wieder zurück in die Liste
Das ist wie man so schön sagt, mit der Kirche ums Dorf gefahren ..

Stell dir mal vor in deiner Liste werden 10.000 Elemente gespeichert, was glaubst du ist schneller.

A) Durch die Liste gehen und an der passenden Stelle einfügen führt zu maximal 10.000 Schleifendurchläufen.

oder

B) Die Liste kopieren, dann sortieren mit BubbleSort und dann wieder zurückkopieren

kopieren : 10.000 Operationen
bubble sort : 10.000 * 10.000 Operationen
zurückkopieren: 10.000 Operationen

macht zusammen mal so grob geschätzt : 100.020.000 Operationen im Vergleich zu 10.000 ist das 10.002 mal mehr

Überleg dir das mal nochmal

Gruß Oli

 

[Spin]

Habe nochmal überlegt^^

Hier überspeicher ich den Wert an i.

/* Einfügen in die Liste an einer bestimmten Position*/
    public void add(int index, TvShow t) {
        /* Anker erstellen*/
        TvShowListElement current = head;
        /* Liste durchlaufen*/
        for (int i = 0; i < elementCount; i++) {

            if(i==index){
                System.out.println("wurde getauscht");
               current.setData(t);

            }
            current = current.getNext();
        }
    }

Nun:

Meine Klasse der ich das hinzufüge:

public class SmartProgramScheduler implements ProgrammScheduler {

    TvShowList list;


    public SmartProgramScheduler() {
        this.list = new TvShowList();
    }

    public void addShow(TvShow t) {
         list.add(t);
    }



    public void sort(){

        /*sortieren*/
        for (int i = 0; i < list.getSize(); i++) {
            for (int j = i + 1; j < list.getSize() - 1; j++) {

                // ersteinmal die Sendezeitenberechnen für jede TvShow
                HMTime current = list.getTvShowAt(i).getAirTime();
                int time = current.getHour() * 60 + current.getMinute();
                /* und für die zeiwete Show*/
                HMTime next = list.getTvShowAt(j).getAirTime();
                int ntime = next.getHour() * 60 + next.getMinute();


                if (time > ntime)
                {
                    TvShow temp = list.getTvShowAt(i);
                    list.add(i, list.getTvShowAt(j));
                    list.add(j,temp);

                }
            }
        }
    }


    public void removeShow(TvShow t) {
        list.remove(t);
    }

    public void display() {
        list.display();
    }

Aufruf:

 System.out.println( "---------------"+"\n"+"Das heutige Programm:" + "\n" + "---------------");
        SmartProgramScheduler sm = new SmartProgramScheduler();
        sm.addShow(a);
        sm.addShow(b);
        sm.addShow(c);

        sm.sort();

        sm.display();

Ausgabe:

Das heutige Programm:
---------------
20:15 Billy Madison (112 Minuten)
Genre: Comedy
21:30 The Descent (120 Minuten)
Genre: Horror (FSK 18)
19:0 Rendezvous mit Joe Black (178 Minuten)
Genre: Romance

Aber nicht sortiert :/

Das Problem ist :

1215
1290

er holt sich nur einmal die umrechnungen in minuten :/

 

[Spin]

Es geht

Es fehlten nur in der Schleife :

das gleich zeichen
Oh man ich ....

<=

grüße , jippie

noch ein bischen ^^

 

[sambalmueslie]

Tja kaum macht man es richtig, schon geht es


Gruß Oli

 

[Spin]

Letzte frage:

 public void sort(){

        /*sortieren*/
        for (int i = 0; i <= list.getSize(); i++) {
            for (int j = i + 1; j <= list.getSize() - 1; j++) {


                // ersteinmal die Sendezeitenberechnen für jede TvShow
                HMTime current = list.getTvShowAt(i).getAirTime();
                int current_run = list.getTvShowAt(i).getRunTime();
                int time = current.getHour() * 60 + current.getMinute();
                int sum = current_run + time;
                /* und für die zeiwete Show*/
                HMTime next = list.getTvShowAt(j).getAirTime();
                int ntime = next.getHour() * 60 + next.getMinute();
               
                if(sum>ntime){
                    System.out.println("***ACHTUNG ÜBERSCHNEIDUNG***");
                }

                if (current.compareTo(next) == 1) 
                {
                    TvShow temp = list.getTvShowAt(i);
                    list.add(i, list.getTvShowAt(j));
                    list.add(j,temp);

                }
            }
        }
    }

Ich habe die Methode ein wenig schick gemacht

Ausgabe:

---------------
Das heutige Programm:
---------------
***ACHTUNG ÜBERSCHNEIDUNG***
20:15 Billy Madison (76 Minuten)
Genre: Comedy
21:30 The Descent (120 Minuten)
Genre: Horror (FSK 18)

Ich möchte aber das die ausgabe anders geschieht.
Nämlich:

---------------
Das heutige Programm:
---------------

20:15 Billy Madison (76 Minuten)
Genre: Comedy
***ACHTUNG ÜBERSCHNEIDUNG***
21:30 The Descent (120 Minuten)
Genre: Horror (FSK 18)

Um das zu realisieren muss ich wohl meinen berechnung auslagern oder ?
Denn meine Ausgabe erfolgt erst in der Methode display.

Müsste also irgendwie nen boolean zurückgeben ..

wenn der true ist .

setDisplayError(true)

Wenn das so ist ..dann raus mit der message ^^
Ist das so gut oli?

oder hast eine idee innerhalb der methode oben?