import bspg.strukturen.*;
import sum.komponenten.*;

/**
 * @author Bernard Schriek
 * @version 24.07.2006
 */
public class Wettkampfliste extends Liste
{
    // Bezugsobjekte

    // Attribute

    // Konstruktor
    public Wettkampfliste()
    {
        super();
    }

    // Dienste
    /**
     * Die aktuelle Wettkampfkarte wird geliefert
     */
    public Wettkampfkarte aktuelleKarte()
    {
        return (Wettkampfkarte) this.aktuellesElement();
    }

    /**
     * Die Wettkampfkarte mit der hšchsten Punktzahl wird geliefert
     */
    public Wettkampfkarte besteKarte(int pArt)
    {
        Wettkampfkarte lBeste, lVergleichskarte;

        if (this.istLeer())
            return null;
        else
        {
            this.zumAnfang();
            lBeste = this.aktuelleKarte();
            this.vor();
            while (!this.istDahinter())
            {
                lVergleichskarte = this.aktuelleKarte();
                if (lVergleichskarte.punkte(pArt) > lBeste.punkte(pArt))
                    lBeste = lVergleichskarte;
                this.vor();
            }
            return lBeste;
        }
    }

    /**
     * Die Wettkampfliste wird mit Bubblesort sortiert
     */
    public void bubblesort(int pArt)
    {
        Wettkampfkarte lKarte1, lKarte2;
        boolean lGetauscht;
        int lDurchlaeufe;

        if (this.laenge() > 1)
        {
            lDurchlaeufe = 0;
            do
            {
                lGetauscht = false;
                this.zumAnfang();
                lKarte1 = this.aktuelleKarte();
                this.vor();
                while (this.aktuellePosition() < this.laenge() - lDurchlaeufe)
                {
                    lKarte2 = this.aktuelleKarte();
                    if (lKarte2.punkte(pArt) > lKarte1.punkte(pArt))
                    {
                        this.ersetzeAktuelles(lKarte1);
                        this.zurueck();
                        this.ersetzeAktuelles(lKarte2);
                        this.vor();
                        lGetauscht = true;
                    }
                    else
                        lKarte1 = lKarte2;
                    this.vor();
                }
                lDurchlaeufe++;
            }
            while (lGetauscht);
        }
    }

    /**
     * Die Wettkampfliste wird mit Selectionsort sortiert
     */
    public void selectionsort(int pArt)
    {
        Wettkampfkarte lKarte;
        Liste lSortierteListe;

        lSortierteListe = new Liste();
        while (!this.istLeer())
        {
            lKarte = this.besteKarte(pArt);
            this.geheZuPosition(this.position(lKarte));
            this.loescheAktuelles();
            lSortierteListe.zumEnde();
            lSortierteListe.fuegeDahinterEin(lKarte);
        }
        this.haengeListeAn(lSortierteListe);
    }

    /**
     * Die Wettkampfliste wird mit Insertionsort sortiert
     */
    public void insertionsort(int pArt)
    {
        Wettkampfkarte lKarte, lVergleichskarte;
        Liste lSortierteListe;
        boolean lPositionGefunden;

        lSortierteListe = new Liste();
        this.zumAnfang();
        while (!this.istLeer())
        {
            lKarte = this.aktuelleKarte();
            this.loescheAktuelles();
            if (lSortierteListe.istLeer())
                lSortierteListe.fuegeDahinterEin(lKarte);
            else
            {
                lSortierteListe.zumAnfang();
                lPositionGefunden = false;
                do
                {
                    lVergleichskarte = (Wettkampfkarte) lSortierteListe
                            .aktuellesElement();
                    if (lKarte.punkte(pArt) > lVergleichskarte.punkte(pArt))
                        lPositionGefunden = true;
                    else
                        lSortierteListe.vor();
                }
                while (!lSortierteListe.istDahinter() && !lPositionGefunden);
                lSortierteListe.fuegeDavorEin(lKarte);
            }
        }
        this.haengeListeAn(lSortierteListe);
    }

    /**
     * Die Wettkampfliste wird mit Quicksort sortiert
     */
    public void quicksort(int pArt)
    {
        Wettkampfliste lLinkeListe, lRechteListe;
        Wettkampfkarte lPivotelement, lKarte;

        if (this.laenge() > 1) // mindestens 2 Elemente, also muss man sortieren
        {
            lLinkeListe = new Wettkampfliste();
            lRechteListe = new Wettkampfliste();
            this.zumAnfang();
            lPivotelement = (Wettkampfkarte) this.aktuellesElement();
            this.vor();
            while (!this.istDahinter())
            {
                lKarte = (Wettkampfkarte) this.aktuellesElement();
                if (lKarte.punkte(pArt) > lPivotelement.punkte(pArt))
                    lLinkeListe.fuegeDahinterEin(lKarte);
                else
                    lRechteListe.fuegeDahinterEin(lKarte);
                this.vor();
            }
            this.entferneAlleElemente();
            lLinkeListe.quicksort(pArt);
            lRechteListe.quicksort(pArt);
            this.haengeListeAn(lLinkeListe);
            this.zumEnde();
            this.fuegeDahinterEin(lPivotelement);
            this.haengeListeAn(lRechteListe);
        }
    }

}