Listen - ungerade Werte entfernen

[Miaming]

Guten Abend zusammen, ich bearbeite gerade eine Aufgabe zum Thema Listen. Ich habe mich bereits darum gekümmert ein Grundgerüst aufzubauen, dass die grundlegende Liste erstellt. Hier mal mein bisheriger Code (Verbesserungen natürlich gerne erwünscht ^^

public class Link 
{ 
    //Attribute 
    int  daten; 
    Link naechster; 
 
    //Konstruktor 
    Link(int daten, Link naechster) 
    { 
        this.daten = daten; 
        this.naechster = naechster; 
    } 
} 
 
 
public class Liste { 
 
   //Attribute 
   protected Link anfang; 
   protected Link ende; 
 
   //Konstruktor 
   public Liste(int startLeer, int endeLeer) 
   { 
        anfang = new Link(startLeer, null); 
        ende = new Link (endeLeer, anfang); 
        anfang.naechster = ende; 
   } 
 
   public void anfuegenElement(int neuerWert) 
   { 
        Link neu = new Link(neuerWert, ende); 
        ende.naechster.naechster = neu; 
        ende.naechster = neu; 
   } 
 
 
   public void entferneUnGeradeElemente()

Mein nun folgendes Problem befindet sich in letzter Codezeile die Methode "entferne ungeradeelemente"

Ziel ist es es unter anderem mit in einem Hauptprogramm eine Liste zu erzeugen, die mir 10 Zufallszahlen erzeugt und im Anschluß durch die Methode entferne ungerade Elemente diese Elemente die ungerade sind entfernt (komisch ausgedrückt wie ich gerade merke^^)

Problem ist, dass es schon für mich als recht aufwendig war dieses Gerüst zu erstellen, vielleicht bin ich auch einfach mit meinen Nerven am Ende. Ich weiß, dass ich in jedem Fall die Methode math.random() brauche. Vorgabe ist hierbei dass die Werte größer 0 und kleiner 1 sein müssen.

Dies realisiert die Methode math.random bereits.

Das Problem ist die Implementierung der Methode ... ich habe das Problem, dass ich nicht weiß wie es sich dann in der Methode mit den ganzen Zeigern bezüglich der Listen verhält :S Könnte mir vielleicht jemand mit einem verständlichen Quellcode (und bitte mit Erklärung sofern möglich) helfen?

Wäre mehr als nett! Ich bedanke mich im voraus!

 

[Xpisto]

Ich habe einen Lösungsansatz enwtickelt, da ich mich auf eine Klausur vorbereite und ich deine Aufgabe quasi als Übung genommen habe. Ich habe auch bei manchen stellen bin ich mir unsicher was ich genau gemacht habe bzw. wofür, vllt kann mir das jemand erklären. (DIese ansätze hab ich mir dan aus den unterlagen zusammengebastelt.

link l = anfang;

while(l.naechster !=ende)
{
     if(l.naechster % 2 == 1)
     {
           l.naechster = l.naehcster.naechster;  // der Zeiger wird auf den übernächsten Zeiger    gelegt, sodass nicht mehr auf das gelöschte Objekt verwiesen wird!

           if(l.naechster == ende)    // da es jetzt durch das löschen durchaus sein kann, dass auf das ende (leeres objekt und nicht mehr auf ein gefülltes objekt verwiesen wird, müssen wir das jetzt auch noch prüfen. 
             {
                 l = ende.naechster;     //gehe ich recht der annahme, dass hier l (anfang) auf das das vorgängerelement des endes zeigT? siehe hierzu beispiel unten
              }
           else
             {
                 l = l.naehcster;
              }
   }

[anfang]-------->[objekt]-------------->[ende]
                      ^                            |
                      |-----------------------|

Nach dem Löschen

Anweisung:

Bedingung erfüllt l.naechster ist ungerade!

l.naechster = l.naehcster.naechster;  //zeigt nun wird auf den nachfolger des ungeraden elements gelegt

           if(l.naechster == ende)    //nun ist der nachfolger l.naechster und wenn dieses objekt das ende ist, muss folgendes passieren:
             {
                 l = ende.naechster;    // Ich weiss nicht genau was gemacht wird, wir der zeiger vom ende auf den anfang gelegt? Wenn ja, wie wird denn sichergestellt das vor dem gelöschten objekt nicht noch ein objekt war?
              }

[anfang]------------------ >              [ende]
  ^                                                    |
  |-------------------------------------------|

 

[Miaming]

Hallo Xpisto,

dein Ansatz mit dem Modulo finde ich schon einmal für die Lösung meiner Aufgabe als sehr gut, damit kann ich zumindest schon einmal feststellen, wie ich die ungeraden Zahlen selektieren kann.

Problem an der Sache: l.naechster = l.naehcster.naechster; damit würde ich dann quasi die Referenz löschen die vom nächsten auf das ungerade Element geht.

Allerdings muss auch die Referenz gelöscht werden die vom gelöschten Element auf das nächste Objekt verweist. Wie stelle ich das jetzt grafisch da?

Schematisch folgendes Beispiel:

[[0]anfang] ---> [[1]elementungerade]---> [[2]elementgerade]--->[[3]elementungerade]--------->[[4]elementgerade]----->[[0]ende]

Wenn ich nun deine Codezeile betrachte: l.naehcster.naechster;

lösche ich damit die Verbindung die Referenz von 2 auf 3 (siehe roter stricht)- da ich somit das ungerade element (3) überspringe verweist. es nun auf das gerade element der 4. Soweit auch richtig. Allerdings ist noch die referenz von 3 zu 4 vorhanden. Also der Zeiger hat noch eine Verbindung vom Vorgänger (die 3) zum geraden Element (der 4) ist der in grün gemalte Strich in meiner kleinen Grafik. Es muss irgendwie zusätzlich noch mit einem Zeiger des Vorgängers gelöst werden damit auch der Zeiger des Vorgängers gelöscht wird. (also der grüne Zeiger) muss gelöscht werden, damit es aufgeht