Array vs. Listen

DS = Datenstruktur DT = Datentyp
Array
Listen
statische DS dynamische DS
feste länge beliebig erweiterbar
es kann ungenutzten Speicherplatz geben es gibt keinen verschnitt
schneller als Listen langsam
der Platz bleibt immer identisch * beim löschen wird automatisch eine neue Verkettung gebildet (es wird aufgerutscht) *
* noch einmal kurz ausführlich was das bedeutet
Angenommen ihr habt das folgende Array:

1
2
3
4
int[] x = new int[10];
x[4] = 12;
x[5] = 15;
x[6] = 30;

Nun weist ihr x[6] den Wert von x[5] zu. Dann haben jetzt x[6] und x[5] den selben Wert.
Dennoch wird die Position von x[4] immer 12 sein, solange ihr diesen nicht explizit ändert.
In einer Liste ist das allerdings anders. Wenn ihr dort jetzt einen Wert an Stelle 5 löscht, so wird die vorherige 6, nun eure neue 5 sein.
Das macht ein direktes ansprechen einer Position so ziemlich unmöglich. Denn die Positonen können sich jederzeit wieder ändern.(siehe auch im Video gleich hier nach)

kurze Einführung in Listen
kleiner Spoiler
Array und Listen werden später noch um die Baumstruktur (Binärbaum) erweitert. Diese ist ebenfalls schneller als die Liste.

Eine weitere Besonderheit bei Listen ist, das bei ihnen der Datensatz endgültig gelöscht werden kann. Bei einem Array kann man nur einen reservierten Platz mit einem neuen Datensatz überschreiben, aber nie endgültig löschen.
Bei der Liste hingegen übernimmt dies automatisch der Garbage Collector

Garbage Collector

Exceptions

hier wird alles erklärt was ihr zum Thema Ausnahmebehandlungen (exceptions) wissen müsst.

try / catch

throws

throws in der main

throw

minimaler Spannbaum

Berechnung des Minimalen Spannbaums

Dies geht einmal über KRUSKAL und einmal über PRIM

hier kurz die wichtigsten Unterschiede:
[später wird dieser Post noch um ein paar Details erweitert]

im wesentlichen:

Kruskal:

– man fängt am kleinsten kanten gewicht an.
– man geht zum nächst kleinen, und das immer so weiter. bis alle knoten einmal besucht worden.
– NUR knoten. nicht kanten. Die Kantengewichte dürfen keine Fläche bilden!

Prim:

– man sucht sich einfach irgendeinen punkt aus. dieser bleibt die ganze zeit über Ausgangspunkt.
– Man prüft immer wieder am aktuellen und allen alten (unbesuchten) kanten, wo ist die kleinste mögliche Kante zum laufen. Und dann wird dort neu verbunden. Das ganze solange bis alle Knoten besucht worden.
– Die Kantengewichte dürfen keine Fläche bilden!

Info Maximaler Spannbaum

Funktioniert im Endeffekt genauso. nur das man hierbei vom größt möglichen Punkt ausgeht, statt dem kleinsten.

Euklidischer Algorithmus

Der Euklidische Algorithmus ist der älteste Algorithmus auf der Welt.
Er ist eine vereinfachte / verkürzte Methode um den GGT zu berechnen.

kurze Wiederholung zum GGT
und auch hier zu lesen

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
 
$x = 55;
$y = 20;
 
while($x != $y)
{
	if($x > $y){
		$x -=$y;
	}
	else {
		$y -= $x;
	}
}
echo $x;
?>

Mein Ansatz zum Euklid

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
 
$x = 18;
$y = 12;
 
while ( $x != 0 && $y != 0){
 
	if($x > $y){
		$x = $x % $y;   
	}else {
		$y = $y % $x;
	}
}
echo $x+$y;  // warum x+y? da einer der beiden werte in jedem Fall 0 sein wird.
             // und der jeweils andere beeinhaltet das ergebnis 
?>

% = Modulo => zur Berechnung des Restes einer Divison.

direkter Vergleich GGT vs Euklid
Vermutlich werdet ihr beim kurzen drüberschauen jetzt denken „Das sieht aber ziemlich gleich aus. Und vor allem sogar beides sehr kurz.“
Auf den ersten Blick mag das so scheinen. Der Code- (Zeit-) Aufwand ist ca. Identisch.
ABER : Der wohl wichtigste Unterschied ist die Laufzeit die euer Algorithmus zum Ziel brauch.
Der Euklid brauch nur halbsoviele durchläufe wie der gute alte GGT.
Wenn ihr mir nicht glaubt, übernehmt den Beispielcode von oben, und lasst zu beginn jeder Schleife eine Ausgabe im Browser machen.
Es lohnt sich also wirklich!

Und jetzt das ganze noch einmal ausführlich:

immer noch nicht genug gelernt?
schaut mal bei proggen.org rein

Maximale Teilsumme

Einfache Algorithmen, dargestellt in php Quellcode.

Max TeilSumme

Berechnung der Maximalen Teilsumme in einem Array

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
 
$randmax = 0;
$bishermax = 0;
$array = array(5,-8,3,3,-5,7,-2,-7,3,5);
 
for ($i = 0;$i < count($array) ; $i++) {
 
	$randmax = max(0, $randmax + $array[$i]);
 
	$bishermax = max($bishermax, $randmax);	
}
    echo $randmax;
?>

Zahlenfolge: 5,-8,3,3,-5,7,-2,-7,3,5
Ergebnis: 8

Einfache Algorithmen [GGT, KGV]

Einfache Algorithmen, dargestellt in php Quellcode.

GGT

Zuerst mal etwas ganz einfaches; der GGT (größte gemeinsame Teiler) => Dieser ist ein teil des EUKLID

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
 
$x = 55;
$y = 20;
 
while($x != $y)
{
	if($x > $y){
		$x -=$y;
	}
	else {
		$y -= $x;
	}
}
echo $x;
?>

Ergebnis : 5
Erst wird geprüft ob die zahlen nicht eh identisch sind, falls ja, ist das dass Ergebnis.
Wenn nicht: schau welche Zahle größer als die andere ist, und zieh dann die kleinere davon ab. Und das ganze solange bis die beiden werte identisch sind.
(Das ganze lässt sich natürlich auch noch anders / komplexer lösen. z.B. mit Modulo (%) )

Ablauf des Algorithmus :
55 – 20 = 35
35 – 20 = 15
15 – 20 = 5

Ergebnis = 5

————————-

KGB

Berechnung des KGV (kleinste gemeinsame vielfaches)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
$m = 1;
$n = 1;
$x = 12;
$y = 18;
 
while ($m * $x != $n * $y){
	if($m * $x > $n * $y){
		$n++;
	}else{
		$m++;
	}	
}
echo $m*$x;
?>

Die Abbruchbedingung ist erneut wenn beide Werte identisch sind.
Dann wird wieder geschaut welcher Wert der größere ist, und der jeweils kleinere erhält bei jedem durchlauf einen neuen multiplikator (anfangs 1, dann 2, 3, 3…n)
Und das ganze wird solange weiter multipliziert, bist die beiden Werte identisch sind.
Dies ist dann das KGV.

Am Anfang haben wir also (1*12) != (1*18)
1*12 > 1*18 – no
2*12 > 1*18 – yes
2*12 > 2*18 – no
3*12 == 2*18 – yes

KGV Ergebnis: 36

Sollten noch etwas unklar sein, oder wenn ihr es noch ausführlicher erklärt haben wollt, schreibt einfach kurz etwas in die Kommentare ^^

————
Frage: Warum eigentlich php ?
Antwort: Weil php „dirty“ ist. php verzeiht einem vieles, und man muss dabei auch nicht vieles beachten. Es gibt zudem keine DT die einen nur unnötig aufhalten.

SuchAlgorithmen

Die bekanntesten SuchAlgorithmen

LINSEARCH: lineare Suche (Sequentielle Suche)
Sehr langsam aber Effektiv. Es wird einfacher jeder Eintrag der Reihe nach angesehen und geschaut ob
es der gesuchte ist.
Vorteil: Diese suche kann auch bei einer Unsortierter Liste angewendet werden.


BINSEARCH: Binäre Suche
„Divide and Conquer“
Es wird der gesamte Datensatz geteilt. Und dann wird geprüft, ob der Gesucht Wert kleiner oder größer als der aktuelle Wert. Wenn kleiner, dann halbiere diesmal die linke Seite, wenn größer, die rechte.
Und das solange, bis der gewünschte Wert gefunden wurde.

hierbei brauch man für 1mio. Datensätze maximal 20 versuche.


EXPSEARCH: Exponentielle Suche
ExpSearch wird verwendet wenn man einen sehr großen Datensatz hat.
D.h. wenn euer Datensatz 32Bit überschreitet bzw. euer Arbeitsspeicher ihn nicht mehr verarbeiten kann.
Man vergibt hier einen Schlüssel, und einen wert der hochgezählt wird.
Man prüft dann ob der gesuchte wert < key ist, falls ja, wird der andere wert verdoppelt. Das ganze wird solang wiederholt, bist der wert > als der schlüssel ist, denn dann hat man den bereich den man durchsuchen muss.
An diesem Punkt, wird jetzt die Binäre Suche durchgeführt. (Suchbereich x/2 bis x )
Ich weiss ein wenig komplex, vielleicht hilft euch dieses Video etwas mehr:

ungefähr auf 32min vorspulen

INTSEARCH: Interpolationssuche
Der IntSearch ist ein sehr komplexer, aber auch Inteligenter Suchalgorithmus.
Anhand einer Mathematischen Formel, findet er direkt zu Anfang die Ungefähre Position des Gesuchten Wertes heraus.
Formel:
[latex] x = links + \frac{gesuchter Wert – Array[links]}{Array[rechts] – Array[links]} * (rechts – links)
[/latex] Mit Links ist der erste Wert in der Liste (oder auch Array) gemeint, und mit rechts der letzte Wert.

Am besten ihr lest euch dazu noch die Erklärungen auf Wikipedia durch.
Oder auch das Video unter ExpSearch.

FIBSEARCH: Fibonacci
Fibonacci ist ein teil der vollständigen Induktion.

Häschen-Beispiel zum allg. Verständnis

siehe auch: Vorlesung 04, rekursion

Vollständige Induktion

Sortieralgorithmen

Sortieren

BubbleSort
Das ganze ist ähnlich wie der InsertionSort. Es wird wieder von Links nach rechts durchgelaufen und verglichen. Nur das diesmal nur maximal einmal getauscht werden Kann. Und wenn jeder einmal verglichen wurde, fängt das ganze wieder von vorne an.


BucketSort

Falls ihr ein gutes Video zum Thema BucketSort kennt, könnt ihr es bitte in die Kommentare schreiben.

BogoSort
Der Psycho-Sort:
Der BogoSort geht mit einer RANDOM Funktion alle Einträge durch. Und das solange, bis per zufall
der richtige Eintrag gefunden wurde..
Das kann mit sehr viel glück sehr schnell gehen, oder es dauert wirklich unendlich. [ [latex] n \to \infty [/latex] ]

HeapSort

Find ich persönlich nicht gut erklärt. Ich suche noch nach ersatz.


InsertionSort
Man geht von Anfang bis Ende jeden wert durch. und prüft dabei jedes mal auf [latex]\le und \ge[/latex]. Sollte der aktuelle wert einmal kleiner sein als der vorherige, wird dieser solange weiter nach links verschoben, bist dies nicht mehr zutrifft. Ein sehr Zeitintensiver Algorithmus.


MergeSort
„Divide and Conquer“
Alle Elemente werden immer wieder halbiert, bis nur noch 1 Wert für sich alleine steht. Dann werden alle wieder zusammengefügt, und dabei getauscht.


SelectionSort
Man sucht zuerst nach der kleinsten zahl. Man vergleichst den ersten Eintrag solange mit anderen Einträgen, bis einer wirklich kleiner ist. Dann wird dieser mit dem bisherigen Wert getauscht. Das ganze wird solange wiederholt bis wirklich der kleinste Wert am Anfang steht.
Dann wird das gleiche mit dem 2ten Wert gemacht. usw. usw.


QuickSort
Man sucht sich eine beliebigen wert heraus. und sortiert anhand von diesem. Er wird nun in der mitte platziert, und jeder wert wird nach dem prinzip [latex]\le und \ge[/latex], nach links und rechts platziert. Dies wird nun immer wieder wiederholt. Ein neuer random* wert aus dem Linken Block, sortieren, das selbe auf der rechten Seite usw.
*Dieser random Wert wird auch häufig Pivotelement genannt.


Spezifikationen (kommen später):
Heap: UpHeap / DownHeap

Formale Algorithmen

Grundwissen / Vorbereitung

Zum einem gibt es mehrere Vorlesungen von verschiedenen Universitäten Online anzusehen.

Was hierbei auch immer ein guter tipp ist: ladet euch Itunes runter. auch wenn ihr gar keine apple Produkte besitzt!

mehr dazu
Denn hier gibt es seit einiger Zeit „Itunes U“. (how to)
Dort stellen Universitäten Weltweit ihre Vorlesungen Online zur Verfügung.
Darüber habt ihr die Möglichkeit, Vorlesungen aus Harvard und Yale anzusehen.
Aber auch von Deutschen Uni’s wie z.B. Aachen, Berlin, Hamburg, München.

z.B.

UniStreams
Der Vorteil von Unistreams: Dort gibt es auch Vorlesungen zum Thema Datenbanksysteme und Computergrafik.


Alternativ:
Logt euch bei Video2Brain mit eurem EDU-Login (Shibboleth) ein.
Und sucht dann nach Algorithmen.
Darunter gibt es z.b. ein zweistündiges Video das über die praktische Anwendung von Algorithmen in verschiedene Programmiersprachen berichtet.

Unter „Videos“ gibt es dann noch ein paar Sachen zum Thema Hash etc.

Was ich auf jedenfal empfehlen kann, ist das Buch: „Taschenbuch der Algorithmen
Dieses findet ihr auch bei uns im Fronter unter FMA.

so ich glaub das reicht erstmal.
Ansonsten google und wikipedia sind eure besten freunde :D

Grundlagen Analysis

das absolute minimum an grundwissen das jeder drauf haben sollte :3

 

Loading...
X