# [HELP!]Rekursiver Algorithmus für eine Koch-Kurve



## Flipbo219 (23. Dezember 2016)

*[HELP!]Rekursiver Algorithmus für eine Koch-Kurve*

Hallo Zusammen,

ich muss in Java eine Koch-Kurve rekursiv ermitteln. 
Dazu habe ich gegeben: 

Nehmen Sie als Anfangskurve eine Linie zwischen den Koordinaten (0,500) und (500,500).
Schreiben Sie ein Programm, das für eine vorgegebene Iterationstiefe die Koordinaten aller
Eckpunkte auf dem Bildschirm ausgibt.
Benutzen Sie einen rekursiven Algorithmus. Die rekursive Funktion
*public static void kochKurve(double ax, double ay, double bx, double by, double rek)*
erhält den Anfangs- und den Endpunkt der zu zeichnenden Linie und die Rekursionstiefe.
Sie können dann folgendermaßen vorgehen:

o Die Funktion überprüft, ob die Rekursionstiefe 0 ist. In diesem Fall gibt sie den
Anfangspunkt aus und beendet sich.
o Ansonsten berechnet sie die 3 Zwischenpunkte und ruft sich selbst 4 Mal rekursiv
auf. Dabei wird von der Rekursionstiefe 1 abgezogen.

Als Testfälle sind gegeben:

Rekursionstiefe 0: (0/500) (500/500)
Rekursionstiefe 1: (0/500) (166,6/500) (250/355,6) (333,3/500) (500/500)
Rekursionstiefe 2: (0/500) (55,5/500) (83,3/451,8) (111,1/500) (166,6/500)
(194,4/451,8) (166,6/403,7) (222,2/403,7) (250/355,6) (277,7/403,7)
(333,3/403,7) (305,5/451,8) (333,3/500) (388,8/500) (416,6/451,8)
(444,4/500) (500/500)

Kann mir jemand erklären wie die Berechnung abläuft? Ich blicke da leider nicht so ganz durch. 

Danke und Lg!

Also das hier ist mein bisheriger Code:


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

		kochKurve(0, 500.4, 500, 500, 1);
	}

	public static void kochKurve(double ax, double ay, double bx, double by, double rek) {
		 if (rek == 0) {
		 System.out.println("Rekursionstiefe " + (int)rek + ": "+ "(" + ax +
		 "/" + ay + ") " + "(" + bx + "/" + by + ")");
		 return;
		 }
		if(rek >= 1) {

			double x1 = (2 * ax) / 3 + bx / 3;
			double y1 = (2 * ax) / 3 + by / 3;
			double x2 = (ax + bx) / 2 + Math.round((Math.sqrt(3) / 6 * (by - ay)));
			double y2 = (ay + by) / 2 + Math.round((Math.sqrt(3) / 6 * (ax - bx)));

			double x3 = ax / 3 + (2 * bx) / 3;
			double y3 = ay / 3 + (2 * by) / 3;

			double x4 = (2 * x3) / 3 + x3 / 3;
			double y4 = (2 * y3) / 3 + y3 / 3;
			
			 System.out.println("Rekursionstiefe " + (int)rek + ": "+ "(" + ax +
					 "/" + ay + ") " + "(" + bx + "/" + by + ")");

			 System.out.println("Punkte :" +"("+ ax + "/" + ay + ") ("+ Math.round(x1*10)/10.0 + "/" + Math.round(y1*10)/10.0 + ") (" + Math.round(x2*10)/10.0
					 + "/" + Math.round(y2*10)/10.0+ ") (" + Math.round(x3*10)/10.0 + "/" + Math.round(y3*10)/10.0+ ") (" + Math.round(x4*10)/10.0 + "/" 
					 + Math.round(y4*10)/10.0 +") ("+ bx + "/" + by+")");

//			System.out.println(" " + x1 + " " + y1 + " " + x2 + " " + y2 + " " + x3 + " " + y3 + " " + x4 + " " + y4);

			kochKurve(ax, ay, x1, y1, rek - 1);
			kochKurve(x1, y1, x2, y2, rek - 1);
			kochKurve(x2, y2, x3, y3, rek - 1);
			kochKurve(x3, y3, x4, y4, rek - 1);
			kochKurve(x4, y4, bx, by, rek - 1);

		}
	}
```

Als Ausgabe bekomme ich :


```
Rekursionstiefe 1: (0.0/500.0) (500.0/500.0)
Punkte :(0.0/500.0) (166.7/166.7) (250.0/356.0) (333.3/500.0) (333.3/500.0) (500.0/500.0))
```

Was auch schon ziemlich nahe an das Ergebnis herankommt, aber halt noch nicht ganz...


----------

