public class LogistikZentrum
{
    private List<Paket> allePakete;
 
    public LogistikZentrum()
    {
        this.allePakete = new List<Paket>();
    }
 
    public List<Paket> GetTop3Schwere(string ort)
    {
        // Schritt 1: Filtern
        List<Paket> nurOrt = new List<Paket>();
        foreach (Paket p in allePakete)
        {
            if (p.GetZielort() == ort)
            {
                nurOrt.Add(p);
            }
        }
 
        // Schritt 2: Absteigend sortieren (Bubble Sort)
        for (int i = 0; i < nurOrt.Count - 1; i++)
        {
            for (int j = 0; j < nurOrt.Count - i - 1; j++)
            {
                if (nurOrt[j].GetGewicht() < nurOrt[j + 1].GetGewicht())
                {
                    Paket temp = nurOrt[j];
                    nurOrt[j] = nurOrt[j + 1];
                    nurOrt[j + 1] = temp;
                }
            }
        }
 
        // Schritt 3: Die ersten 3 nehmen
        List<Paket> top3 = new List<Paket>();
        for (int i = 0; i < 3 && i < nurOrt.Count; i++)
        {
            top3.Add(nurOrt[i]);
        }
 
        return top3;
    }
}

Dieses Level ist kein neuer Algorithmus – es ist eine Kombination aus allem, was du in Sektion 2 gelernt hast. Die Lösung bricht das Problem in drei klar getrennte Schritte auf, von denen jeder für sich bereits bekannt ist.

List<Paket> nurOrt = new List<Paket>();
foreach (Paket p in allePakete)
{
    if (p.GetZielort() == ort)
    {
        nurOrt.Add(p);
    }
}

Zuerst wird eine neue Hilfsliste nurOrt aufgebaut, die nur Pakete für den gesuchten Zielort enthält. Die Originalliste allePakete bleibt unverändert. Das Prinzip kennst du bereits aus FilterePakete().

if (nurOrt[j].GetGewicht() < nurOrt[j + 1].GetGewicht())

Der Bubble-Sort-Algorithmus aus Level 8 kommt hier wieder zum Einsatz – mit einem einzigen Unterschied: Der Vergleichsoperator ist jetzt < statt >. Das bewirkt, dass größere Elemente nach vorne wandern statt nach hinten, die Liste also absteigend sortiert wird.

for (int i = 0; i < 3 && i < nurOrt.Count; i++)
{
    top3.Add(nurOrt[i]);
}

Da die Liste jetzt absteigend sortiert ist, stehen die drei schwersten Pakete an den Positionen 0, 1 und 2. Diese werden in eine neue Liste top3 übertragen und zurückgegeben.

Die Bedingung i < nurOrt.Count ist dabei wichtig: Enthält nurOrt weniger als 3 Pakete (z.B. nur 2 für diesen Zielort), würde nurOrt[2] sonst einen Laufzeitfehler auslösen. Die Schleife stoppt dann automatisch früher.

Die drei Schritte müssen in genau dieser Reihenfolge ausgeführt werden:

1. Erst filtern – sonst sortiert man Pakete, die gar nicht relevant sind.
2. Dann sortieren – sonst weiß man nicht, welche die schwersten sind.
3. Zuletzt die Top 3 auswählen – erst jetzt stehen sie vorne.

Tauscht man z.B. Schritt 2 und 3, nimmt man drei beliebige Pakete und sortiert die – das Ergebnis wäre falsch.

Hinweis für Fortgeschrittene: Dasselbe lässt sich in einer einzigen Zeile mit LINQ ausdrücken:

return allePakete.Where(p => p.GetZielort() == ort) 		// Filtern
                 .OrderByDescending(p => p.GetGewicht()) 	// Absteigend sortieren
                 .Take(3) 									// Die ersten 3 nehmen
                 .ToList();

Im Abitur ist diese Schreibweise in der Regel nicht erwartet – dort soll der Algorithmus explizit nachvollziehbar sein.