Operationen einfach verketteter Listen

[Hacer]

Hallo!!
Ich habe bald eine Klausur in Programmierung und versuche schon seit gestern eine Altklausur zu lösen und zwar geht es hier um die Methoden split und checkAvailability. Weil ich noch nie eine main Methode erstellt habe, weiß ich nicht ob mein Code richtig ist oder nicht.

public class Train {
    private Coach firstCoach= null;
    private Coach lastCoach = null;
   
    public void append(Coach c){
        if(firstCoach== null){
            firstCoach= lastCoach=c;
        }else{
            lastCoach.setNext(c);
            lastCoach=c;
        }
    }
    public void remove(){
        if(firstCoach == null){
            return;
        }
        if(firstCoach.getNext()==null){
            lastCoach= firstCoach= null;
        }else{
            lastCoach= firstCoach;
            while(lastCoach.getNext().getNext()!=null){
                lastCoach =lastCoach.getNext();
            }
            lastCoach.setNext(null);
        }
    }
    public Train split(int n){
        Coach pointer = firstCoach;
        Train neuerZug = new Train();
        while(pointer!=null ){
            pointer= pointer.getNext();
            neuerZug.append(pointer.getNext());
            pointer.setNext(null);
        }
        //neuerZug.append(pointer.getNext());
        //pointer.setNext(null);
        return neuerZug;
    /*    for(int i=0; i<n; i++){
            pointer =pointer.getNext();
            Train neuerZug = new Train();
            neuerZug.append(pointer.getNext());
            pointer.setNext(null);
            return neuerZug;
        }*/
   
       
    }
    public boolean CheckAvailability(int[] passengers){
        int kapazitätWaggon =50;
        Coach pointer = firstCoach;
        for(int i=0; i<passengers.length;i++){
            if(passengers[i]>kapazitätWaggon ||getSize()< passengers.length){
                return false;
            }else{
                if(passengers[i]<kapazitätWaggon&& passengers[i]+pointer.getNumberOfPassengers()>kapazitätWaggon){
                    return false;
                }
                pointer=pointer.getNext();
            }
           
        }
        return true;
        /*if(firstCoach!=null){
            Coach pointer = firstCoach;
            for(int i =0; i<passengers.length;i++){
                if(passengers[i]+ pointer.getNumberOfPassengers()>50){
                    return false;
                    pointer=pointer.getNext();
                }
            }
        }
        return true;*/
       
    }
    public int getSize(){
        if(firstCoach==null){
            return 0;
        }
        int size=0;
        Coach pointer= firstCoach;
        while(pointer!=null){
            size++;
            pointer=pointer.getNext();
        }
        return size;
    }

 

[Bitfehler]

Eine main-Methode sehe ich in deinem Code nicht.
Bitte stell die Frage konkreter, mir ist unklar was du wissen willst.
Übersetzt dein Code? Schon mal ausgeführt und geguckt, was passiert? Passiert das, was passieren soll?

 

[Hacer]

@Bitfehler ich kann keine main- Methoden erstellen.
Bei der split-Methode muss man einen Zug auf die ersten n Waggons in unveränderter Reihenfolge verkürzen und einen neuen Zug mit den übrigen Waggons erstellen.

Bei der CheckAvalaibility Methode muss man überprüfen, ob es genug Plätze im Waggon gibt und jeder Waggon hat die Kapazität 50. Das Array gibt die Anzahl an Passagieren, die eingefügt werden sollen an.

 

[Bitfehler]

Split erscheint mir beim groben drüber gucken falsch.
Probiere doch einfach mal deinen Code aus, dann wirst du sehen, was da wahrscheinlich schief gehen wird.

Bei der anderen Methoden erschließt sich mir die for-Schleife noch nicht. Wenn es mehr Passagiere gibt, als es Plätze gibt, brauche ich das doch nicht für jeden Passagier prüfen. Abgesehen davon, dass da eh ein return ist.

 

[Hacer]

@Bitfehler erstmal danke für die Antwort. Würde es dann gehen, wenn ich die for-Schleife weglasse und statt: if(passengers>kapazitätWaggon ||getSize()< passengers.length)
if(passengers[0]>kapazitätWaggon) schreibe?

 

[Jardcore]

Wie wäre es wenn du uns einmal die Aufgabenstellung beschreibst, dann könnten wir vielleicht auch genau darauf eingehen. Es kann ja sein, das dein Code die Aufgabenstellung schon falsch interpretiert.

 

[VfL_Freak]

Moin,

Würde es dann gehen, wenn ich die for-Schleife weglasse

von welcher FOR-Schleife reden wir hier?
Der anfangs Auskommentierten?
Die wird eh' nie durchlaufen, da davor ein RETURN steht !!

und statt: if(passengers>kapazitätWaggon || getSize()< passengers.length)
if(passengers[0]>kapazitätWaggon) schreibe?

Der Wert von passengers[0] hat doch wohl nichts mit der Kapazität des Waggons zutun ...

So ganz verstehe ich auch nicht, was Du eigentlich willst/sollst ...

Gruß Kalus

 

[Hacer]

MOIN!!
@Jardcore @VfL_Freak
Also hier ist die Aufgabenstellung. Die Lösung die dadrunter steht, ist nicht von mir.

 

[Hacer]

Und da waren noch diese beiden Codes gegeben.

 

[Saheeda]

@Bitfehler ich kann keine main- Methoden erstellen.

Warum kannst du keine main erstellen?

 

[Jardcore]

Aus der Aufgabenstellung lese ich folgendes. Und hier eine Möglichkeit dies umzusetzen.

public boolean checkAvailability(int[] passengers) {
        Coach currentCoach = firstCoach;
        int index = 0;
        int maxPassangersPerCoach = 50;
   
        while(currentCoach != null) {
            // not enought coaches
            if(passengers.length < index + 1) {
                return false;
            }
       
            int passengersCount = passengers[index];
       
            // reached capacity
            if(passengersCount + currentCoach.getNumberOfPassengers() > maxPassangersPerCoach) {
                return false;
            }
       
            currentCoach = currentCoach.getNext();
            index++;
        }
   
        // everything is fine
        return true;
    }

Und hiermit hab ichs getestet.

public class TestTrain_checkAvailability {
    private Train train = new Train();

    @Before
    public void before() {
        int numberOfCouches = 5;
        for(int i = 0; i < numberOfCouches; i++) {
            // append empty couches
            train.append(new Coach(0));
        }
    }

    @Test
    public void testNotEnoughtCouches() {
        int[] passengers = new int[] { 1 };
        assertThat(train.checkAvailability(passengers), is(false));
    }

    @Test
    public void testEnoughCapacityForPassengers() {
        int[] passengers = new int[] { 1, 10, 10, 10, 10 };
        assertThat(train.checkAvailability(passengers), is(true));
    }

    @Test
    public void testNotEnoughCapacityForPassengers() {
        int[] passengers = new int[] { 1, 51, 10, 10, 10 };
        assertThat(train.checkAvailability(passengers), is(false));
    }
}

Übrigens kannst du, wenn du Eclipse verwendest einfach "main" schreiben und dann Strg+Leertaste drücken und hast deine fertige main()-Methode

 

[Hacer]

@Saheeda weil wir immer main- Methoden zur Verfügung gestellt bekommen haben. Ich habe zwar versucht eine main-Methode zu erstellen war da nicht so erfolgreich. Da kam dann split trainTrain@4e2c390c raus

public static void main(String[] args){
        Train train = new Train();
       

        System.out.printf("split train", train.split(3));
        Coach coach1 = new Coach(20);
        Coach coach2 = new Coach(30);
        Coach coach3 = new Coach(40);
        Coach coach4 = new Coach(20);
       
        train.append(coach1);
        train.append(coach2);
        train.append(coach3);
        train.append(coach4);
       
        Train train2 = train.split(2);
        System.out.println(train);
       
    }

 

[Joose]

weil wir immer main- Methoden zur Verfügung gestellt bekommen haben.

public static void main(String[] args) {
      
    }

Aus mehr besteht eine main-Methode auch nicht. Was diese Methode nun ausführt bleibt dem Programmierer überlassen

Ich habe zwar versucht eine main-Methode zu erstellen war da nicht so erfolgreich. Da kam dann split trainTrain@4e2c390c raus

Da kommt "genau" das raus was du programmiert hast

.....
        System.out.printf("split train", train.split(3)); // hier gibst du "split train" aus
.......
        System.out.println(train); // hier willst du das objekt ausgeben. Java weiß ja nicht wie du das Objekt ausgegeben haben willst und verwendet daher eine Standardimplementierung aus Klassenname@Speicheradresse

 

[Hacer]

@Jardcore @Joose vielen lieben Dank euch beiden

 

[Hacer]

Ich habe noch eine Frage bezüglich der split-Methode und zwar wie kann ich die n+1te Waggon in den Zug einfügen?

public Train split(int n){
      Coach pointer =firstCoach;
      for(int i =0; i<=n; i++){
            pointer=pointer.getNext();
      }
      Train neuerZug = new Train();
       neuerZug.append(pointer.getNext());//greife ich hier jetzt auf den Wert aus der For-schleife? und falls nicht geht es dann, wenn ich dies in die for-schleife einfüge und den neuen Zug ganz am Anfang erstelle?
       pointer.setNext(null);
       return neuerZug;
}

 

[Jardcore]

Wo steht eigentlich etwas von split() In der Aufgabenstellung nicht, bzw du hast zwei Mal das gleiche gepostet.
Aber theoretisch musst du einfach sowas machen.

Coach brandNewCoach = new Coach(...);
lastCoach.setNext(brandNewCoach);
lastCoach = brandNewCoach;

//Ausgangslage
                       lastCouch
                          v
TRAIN => [  Coach 1 ]-[ Coach 2 ]

//Schritt 1
TRAIN => [  Coach 1 ]-[ Coach 2 ] - [ brandNewCoach ]

                                       lastCouch
//Schritt 2                               v
TRAIN => [  Coach 1 ]-[ Coach 2 ] - [ brandNewCoach ]

 

[Hacer]

Hier ist die Aufgabe.

 

[Jardcore]

Die Theorie wäre:
Du erstellst einen neuen Zug (Zug#2)
Du gehst die Waggons des aktuellen Zugs(Zug#1) durch und zählst dabei hoch.
Wenn nun nun bei dem Waggon angekommen bist, ab dem getrennt werden soll, setzt du diesen beim Zug#1 als deinen letzten Waggon.
Ab nun musst du alle weiteren Waggons zum Zug#2 hinzufügen.
Wenn du alle Waggons durchgegangen bist musst du noch den letzten Waggon abkoppelt XD
Also lastCouch.setNext(null); setzen.

Wenn man das einfach so runterschreibt sieht das wie folgt aus. Wahrscheinlich kann man das noch optimieren, aber das ist die genaue Umsetzung von der Theorie zur Praxis.

public Train split(int n) {
        Train train = new Train();
        int countOfCoaches = 1;
      
        Coach currentCoach = firstCoach;
        while(currentCoach != null) {
          
            if(countOfCoaches == n) {
                lastCoach = currentCoach;
              
            } else if(countOfCoaches > n) {
                train.append(currentCoach);
            }
            countOfCoaches++;
            currentCoach = currentCoach.getNext();
        }
      
        lastCoach.setNext(null);
      
        return train;
    }

 

[Meniskusschaden]

Eigentlich müsste es doch auch genügen, nur einen Waggon umzukoppeln, denn dessen Folgewaggons können ja seine Folgewaggons bleiben. Ein paar Referenzen wie z.B. lastCoach muß man natürlich trotzdem in Ordnung bringen.

 

[Hacer]

@Meniskusschaden genau man könnte doch den n+1ten Waggon einfach in den neuen Zug einfügen und mit pointer.getNext () die r3stlichen auch einfügen oder ??

 

[Flown]

Also ich seh das wie @Meniskusschaden. Man muss nur mit Pointer jonglieren, denn die Struktur ändert sich ja nicht und man kann ja auf alle privaten Felder von Train zugreifen:

public class Train {
  private Coach firstCoach = null;
  private Coach lastCoach = null;
  
  public void append(Coach c) {
    if (firstCoach == null) {
      firstCoach = lastCoach = c;
    } else {
      lastCoach.setNext(c);
      lastCoach = c;
    }
  }
  
  public boolean checkAvailability(int[] passengers) {
    Coach c = firstCoach;
    for (int i = 0; i < passengers.length; i++) {
      if (c == null || c.getPassengers() < passengers[i]) {
        return false;
      }
      c = c.getNext();
    }
    return true;
  }
  
  public Train split(int n) {
    Train result = new Train();
    Coach current = null;
    Coach next = firstCoach;
    for (int i = 0; i < n && next != null; i++) {
      current = next;
      next = next.getNext();
    }
    result.firstCoach = next;
    result.lastCoach = lastCoach;
    if (current == null) {
      firstCoach = lastCoach = null;
    } else {
      lastCoach = current;
      current.setNext(null);
    }
    return result;
  }
  
  public void remove() {
    if (firstCoach == lastCoach) {
      firstCoach = lastCoach = null;
    } else {
      Coach c = firstCoach;
      while (c.getNext() != lastCoach) {
        c = c.getNext();
      }
      lastCoach = c;
    }
  }
  
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append('[');
    for (Coach c = firstCoach; c != null; c = c.getNext()) {
      builder.append(c.getPassengers());
      if (c != lastCoach) {
        builder.append(", ");
      }
    }
    return builder.append(']').toString();
  }
}

 

[Meniskusschaden]

@Meniskusschaden genau man könnte doch den n+1ten Waggon einfach in den neuen Zug einfügen und mit pointer.getNext () die r3stlichen auch einfügen oder ??

Nicht ganz, denn durch das Umhängen des n+1ten Waggons hängen die restlichen ja schon automatisch am neuen Zug. @Flown hat es ja bereits gezeigt.

 

[Hacer]

@Flown @Meniskusschaden @Jardcore vielen dank