public class Applikation
{
	public static void main (String args[])
	{
		// Es werden Konten erzeugt und beschriebeng
		Konto konto1 = new Konto("123456", 50);
		Konto konto2 = new Konto("512515", 88);
		Konto konto3 = new Konto("673737", 14);
		Konto konto4 = new Konto("22515", 112);
		Konto konto5 = new Konto("5125", 948424);
		Konto konto6 = new Konto("999999", 25);
		// es wird eine kontoliste erzeugt und beschrieben
		KontoListe kontoliste = new KontoListe();
		// Die Konten werden in die Liste eingetragen
		kontoliste.kontoEintragen(konto1);
		kontoliste.kontoEintragen(konto2);
		kontoliste.kontoEintragen(konto3);
		kontoliste.kontoEintragen(konto4);
		kontoliste.kontoEintragen(konto5);
		kontoliste.kontoEintragen(konto6);


		kontoliste.quicksortstart();
		System.out.println ("\nSortierte Konten:\n========");
		kontoliste.allekontenAusgeben ();
	}
}

import java.util.Vector; // Ich binde die Bibliothek für die Vektoren ein


public class KontoListe extends Vector // Ich initialisiere eine Klasse Kontoliste die von der Oberklasse Vektor ihre Werte vererbt bekommt.
{
	public void kontoEintragen (Konto konto) // Diese Funktion bekommt ein Konto übergeben
	{
		this.add(konto); // Die Funktion add fügt das jeweilige Objekt an das Ende des jeweiligen Vectors ein
	}


	public boolean kontoLschen (Konto konto)
	{
		return this.remove (konto); // Die Funktion boolean remove entfernt das Objekt das ihr übergeben wird bzw. das erste Vorkommen des Objekts ist das Objekt nicht vorhanden wird nichts verändert.
	}


	public boolean kontoVorhanden (Konto konto) //Methode, die überprüft, ob ein oder mehrere Konten vorhanden sind
	{
		return this.contains(konto); // wenn das jeweilige Objekt enthalten ist liefert die Funktion contains "true" zurück
	}

	public int getAnzahl ()
	{
		return this.size(); // diese Funktion liefert die größe des jeweiligen Vectors mit
	}


	public Konto getKonto (int index)
	{
		return (Konto)this.get(index); // Hier wird ein Konto zurückgegeben aus dem aktuellem Vector mit dem index index
	}


	public void allekontenAusgeben () // Funktion um alle Konton auszugeben
	{
		for (int i = 0; i < this.size(); i++)
		{
			Konto temp = (Konto)this.get(i);
			System.out.println (temp.toString());
		}
	}

	public Konto sucheKonto(String kontonummer) // Die lineare Suche! es wird die Kontonummer des zu suchenden Kontos übergeben.
	{
		int i=0; // Eine Zählervariable vom Typ Integer wird intialisiert.
		while(kontonummer!=this.getKonto(i).kontonummer) // Eine while Schleife Solange die übergebene Kontonummer nicht gleich der Kontonummer des Kontos mit dem Index i ist führe diese Schleife aus.
		{
			i++; // Die Zählervariable wird jeweils um eins erhöht.
		}
		return getKonto(i); // Sobald die Schleife nicht mehr durchgeführt wird muss die am Anfang übergebene Kontonummer gleich der kontonummer des Kontos mit dem index i sein. Deshalb kann jetzt das Konto mit dem Index i zurückgegeben werden. Es ist jetzt das gesuchte Konto.
	}

	public void quicksortstart()
	{
	quicksort(0, this.size()-1); // Hier beginnt der Quicksort indem ich der methode quicksort die ersten links/rechts grenzen bergebe nmlich von 0 - zur gesamtgre -1 (z.b. bei 10 werten 9 weil von 0-9 = 10 Konten)
	}

	public void quicksort(int linkegrenze,int rechtegrenze) // (Der eigentlich Sortierbeginn dem eine Linke und eine Rechte Grenze bergeben wird.)
	{
		if(linkegrenze < rechtegrenze) // Wenn die Linke Grenze grer wre als der Rechte(Oder gleich der Rechten) wrde die Sortierung keinen Sinn ergeben oder die Liste wre schon sortiert daher wird das ganze hier berprft. Es wird die Sortiermglichkeit besttigt.
		{
			int pivotwert = format(linkegrenze,rechtegrenze); // Hier wird ein Pivotwert aus der format Funktion abgerufen dass heit die Grenze mit der im nchsten Durchgang gearbeitet wird sei es fr die eine oder andere Hlfte beim ersten mal ist dies einer der beiden ausgetauschten Werte.
			quicksort(linkegrenze,pivotwert); // Die eine Hlfte (Beim ersten durchlauf alles links vom pivotwert) wird sortiert
			quicksort(pivotwert+1,rechtegrenze); // Die andere Hlfte (Beim ersten durchlauf alles rechte vom pivotwert) wird sortiert
		}
	}

	public int format(int linkegrenze,int rechtegrenze)
	{
		Konto pivotkonto =(Konto)this.get(linkegrenze); // Das Konto Pivotkonto wird deklariert und ihm wird der Wert des Kontos mit dem Index der Linken Grenze zugeordnet also das "linkeste" Element
		int i = linkegrenze; // Eine Zwischenvariable bekommt den Wert der Linkengrenze zugewiesen
		int b = rechtegrenze; // Eine Zwischenvariable bekommt den Wert der Rechtengrenze zugewiesen
		while(i < b)			// Die While Schleife findet statt insofern die linkegrenze (die ja in i steckt) kleiner als die rechtegrenze (die ja in b steckt)
		{
			while(((Konto)this.get(i)).getKontonummer().compareToIgnoreCase(pivotkonto.getKontonummer()) < 0 )i++; // zu (Konto): Definiert dass jedes Objekt dass aus dem Vektor kommt in ein Konto geschrieben wird da Object eine Oberklasse von Konto ist wäre es ohne dies nicht möglich die Kontonummer abzurufen. Deshalb lege ich fest dass das auszugebende Object ein Konto ist. // Geht solange vom linkesten wert (links innerhalb des aktuellen bereichs) immer um eines weiter nach oben bis ein element grer als das Pivotelement ist
			while(((Konto)this.get(b)).getKontonummer().compareToIgnoreCase(pivotkonto.getKontonummer()) > 0 )b--; // Geht solange vom rechtesten wert (rechts innerhalb des aktuellen bereichs) immer um eines weiter nach unten bis ein element kleiner als das Pivotelement ist
			if (i < b) tausche(i,b); // Wenn beide While schleifen durch sind also 2 zu tauschende Werte gefunden wurden werden diese ber die funktion tausche vertauscht
		}
		return b; // Der Wert b also der wert der von der rechten auf die linke Seite vertauscht wurde wird zurckgegeben.
	}

	public void tausche(int linkerwert,int rechterwert) // Die Funktion die, die beiden Werte im Endeffekt tauscht. Bekommt logischerweise die zu tauschenden werte.
	{
		Konto tempkonto = (Konto)this.get(linkerwert);  // Hier wird ein neues Konto angelegt als Zwischenspeicher denn wenn ich den einen wert an den platz des anderen gepackt hab ist dieser ja dort nicht mehr daher speicher ich einen vorher weg.
		this.set(linkerwert,this.get(rechterwert)); // Hier wird dann also der rechte wert(bzw. das konto mit dem index) an die stelle des linken werts gesetzt
		this.set(rechterwert, tempkonto); // Hier wird der linke wert den wir ja vorher in der tempkonto gespeichert haben auf die Position des kontos mit dem index des rechten werts gesetzt.
	}
}