https://ls14-eini.cs.tu-dortmund.de/api.php?action=feedcontributions&feedformat=atom&user=Marius
EINI - Benutzerbeiträge [de]
2026-05-23T02:06:03Z
Benutzerbeiträge
MediaWiki 1.26.2
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1667
Sortieren
2016-07-31T12:59:23Z
<p>Marius: /* Mergesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des [[Arrays]] zu bewegen. Somit besteht das Ende des Arrays immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Array vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Array sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Arrays dabei zu "verschieben". Da dieses Verfahren bei Arrays viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''1'''</span>, 5, <span style="color:red>'''4'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''0'''</span>, 5, 4, 8, <span style="color:red>'''1'''</span>, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 8, 1, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''1'''</span>, 5, 8, <span style="color:red>'''4'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''2'''</span>, 8, 5, <span style="color:red>'''4'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 4, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, 8, 5, 6, 9, 7, <span style="color:red>'''4'''</span>]<br />
[0, 1, 2, 3, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 6, 9, 7, 4]<br />
[0, 1, 2, 3, <span style="color:red>'''4'''</span>, 8, 6, 9, 7, <span style="color:red>'''5'''</span>]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 5]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''5'''</span>, 8, 9, 7, <span style="color:red>'''6'''</span>]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>, 6]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''6'''</span>, 9, 8, <span style="color:red>'''7'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>, 7]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus. Das eingegebene Array wird hierbei solange in zwei Hälften geteilt, bis jedes Teilarray nur noch eine Zahl enthält. Danach werden die Teilarrays wieder zusammengesetzt. Dabei wird bei der Zusammensetzung so sortiert, dass am Ende nur noch ein sortiertes Array vorhanden ist.<br />
<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[5, 4, 1, 8, 0] ; [2, 6, 9, 7, 3]<br />
[5, 4] ; [1, 8, 0] ; [2, 6] ; [9, 7, 3]<br />
[5] ; [4] ; [1, 8] ; [0] ; [2] ; [6] ; [9] ; [7, 3]<br />
[5] ; [4] ; [1] ; [8] ; [0] ; [2] ; [6] ; [9]; [7] ; [3]<br />
[4, 5] ; [1, 8] ; [0, 2] ; [6, 9] ; [3, 7]<br />
[1, 4, 5, 8] ; [0, 2, 6, 9] ; [3, 7]<br />
[0, 1, 2, 4, 5, 6, 8, 9] ; [3, 7]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Array vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilarrays, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilarrays werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Array in Teilarrays der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilarrays und damit das gesamte Array. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1666
Sortieren
2016-07-31T12:58:11Z
<p>Marius: /* Mergesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des [[Arrays]] zu bewegen. Somit besteht das Ende des Arrays immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Array vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Array sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Arrays dabei zu "verschieben". Da dieses Verfahren bei Arrays viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''1'''</span>, 5, <span style="color:red>'''4'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''0'''</span>, 5, 4, 8, <span style="color:red>'''1'''</span>, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 8, 1, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''1'''</span>, 5, 8, <span style="color:red>'''4'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''2'''</span>, 8, 5, <span style="color:red>'''4'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 4, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, 8, 5, 6, 9, 7, <span style="color:red>'''4'''</span>]<br />
[0, 1, 2, 3, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 6, 9, 7, 4]<br />
[0, 1, 2, 3, <span style="color:red>'''4'''</span>, 8, 6, 9, 7, <span style="color:red>'''5'''</span>]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 5]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''5'''</span>, 8, 9, 7, <span style="color:red>'''6'''</span>]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>, 6]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''6'''</span>, 9, 8, <span style="color:red>'''7'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>, 7]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus. Das eingegebene Array wird hierbei solange in zwei Hälften geteilt, bis jedes Teilarray nur noch eine Zahl enthält. Danach werden die Teilarrays wieder zusammengesetzt. Dabei wird bei der Zusammensetzung so sortiert, dass am Ende nur noch ein sortiertes Array vorhanden ist.<br />
<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Array vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilarrays, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilarrays werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Array in Teilarrays der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilarrays und damit das gesamte Array. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1665
Sortieren
2016-07-31T12:57:35Z
<p>Marius: /* Mergesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des [[Arrays]] zu bewegen. Somit besteht das Ende des Arrays immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Array vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Array sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Arrays dabei zu "verschieben". Da dieses Verfahren bei Arrays viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''1'''</span>, 5, <span style="color:red>'''4'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''0'''</span>, 5, 4, 8, <span style="color:red>'''1'''</span>, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 8, 1, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''1'''</span>, 5, 8, <span style="color:red>'''4'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''2'''</span>, 8, 5, <span style="color:red>'''4'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 4, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, 8, 5, 6, 9, 7, <span style="color:red>'''4'''</span>]<br />
[0, 1, 2, 3, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 6, 9, 7, 4]<br />
[0, 1, 2, 3, <span style="color:red>'''4'''</span>, 8, 6, 9, 7, <span style="color:red>'''5'''</span>]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 5]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''5'''</span>, 8, 9, 7, <span style="color:red>'''6'''</span>]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>, 6]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''6'''</span>, 9, 8, <span style="color:red>'''7'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>, 7]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus. Das eingegebene Array wird hierbei solange in zwei Hälften geteilt, bis jedes Teilarray nur noch eine Zahl enthält. Danach werden die Teilarrays wieder zusammengesetzt. Dabei wird bei der Zusammensetzung so sortiert, dass am Ende nur noch ein sortiertes Array vorhanden ist.<br />
<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Array vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilarrays, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilarrays werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Array in Teilarrays der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilarrays und damit das gesamte Array. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1529
Sortieren
2016-06-25T16:03:51Z
<p>Marius: /* Insertionsort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''1'''</span>, 5, <span style="color:red>'''4'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''0'''</span>, 5, 4, 8, <span style="color:red>'''1'''</span>, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 8, 1, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''1'''</span>, 5, 8, <span style="color:red>'''4'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''2'''</span>, 8, 5, <span style="color:red>'''4'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 4, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, 8, 5, 6, 9, 7, <span style="color:red>'''4'''</span>]<br />
[0, 1, 2, 3, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 6, 9, 7, 4]<br />
[0, 1, 2, 3, <span style="color:red>'''4'''</span>, 8, 6, 9, 7, <span style="color:red>'''5'''</span>]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 5]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''5'''</span>, 8, 9, 7, <span style="color:red>'''6'''</span>]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>, 6]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''6'''</span>, 9, 8, <span style="color:red>'''7'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>, 7]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1528
Sortieren
2016-06-25T16:03:39Z
<p>Marius: /* Insertionsort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''1'''</span>, 5, <span style="color:red>'''4'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[<span style="color:red>'''0'''</span>, 5, 4, 8, <span style="color:red>'''1'''</span>, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 8, 1, 2, 6, 9, 7, 3]<br />
[0, <span style="color:red>'''1'''</span>, 5, 8, <span style="color:red>'''4'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 2, 6, 9, 7, 3]<br />
[0, 1, <span style="color:red>'''2'''</span>, 8, 5, <span style="color:red>'''4'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 4, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''4'''</span>, 8, <span style="color:red>'''5'''</span>, 6, 9, 7, 3]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, 8, 5, 6, 9, 7, <span style="color:red>'''4'''</span>]<br />
[0, 1, 2, 3, <span style="color:red>'''5'''</span>, <span style="color:red>'''8'''</span>, 6, 9, 7, 4]<br />
[0, 1, 2, 3, <span style="color:red>'''4'''</span>, 8, 6, 9, 7, <span style="color:red>'''5'''</span>]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 5]<br />
[0, 1, 2, 3, 4, <span style="color:red>'''5'''</span>, 8, 9, 7, <span style="color:red>'''6'''</span>]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>, 6]<br />
[0, 1, 2, 3, 4, 5, <span style="color:red>'''6'''</span>, 9, 8, <span style="color:red>'''7'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>, 7]<br />
[0, 1, 2, 3, 4, 5, 6, <span style="color:red>'''7'''</span>, 9, <span style="color:red>'''8'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, <span style="color:red>'''8'''</span>, <span style="color:red>'''9'''</span>]<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1527
Sortieren
2016-06-25T15:59:15Z
<p>Marius: /* Insertionsort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
['''4''', '''5''', 1, 8, 0, 2, 6, 9, 7, 3]<br />
['''1''', 5, '''4''', 8, 0, 2, 6, 9, 7, 3]<br />
['''0''', 5, 4, 8, '''1''', 2, 6, 9, 7, 3]<br />
[0, '''4''', '''5''', 8, 1, 2, 6, 9, 7, 3]<br />
[0, '''1''', 5, 8, '''4''', 2, 6, 9, 7, 3]<br />
[0, 1, '''4''', 8, '''5''', 2, 6, 9, 7, 3]<br />
[0, 1, '''2''', 8, 5, '''4''', 6, 9, 7, 3]<br />
[0, 1, 2, '''5''', '''8''', 4, 6, 9, 7, 3]<br />
[0, 1, 2, '''4''', 8, '''5''', 6, 9, 7, 3]<br />
[0, 1, 2, '''3''', 8, 5, 6, 9, 7, '''4''']<br />
[0, 1, 2, 3, '''5''', '''8''', 6, 9, 7, 4]<br />
[0, 1, 2, 3, '''4''', 8, 6, 9, 7, '''5''']<br />
[0, 1, 2, 3, 4, '''6''', '''8''', 9, 7, 5]<br />
[0, 1, 2, 3, 4, '''5''', 8, 9, 7, '''6''']<br />
[0, 1, 2, 3, 4, 5, '''7''', 9, '''8''', 6]<br />
[0, 1, 2, 3, 4, 5, '''6''', 9, 8, '''7''']<br />
[0, 1, 2, 3, 4, 5, 6, '''8''', '''9''', 7]<br />
[0, 1, 2, 3, 4, 5, 6, '''7''', 9, '''8''']<br />
[0, 1, 2, 3, 4, 5, 6, 7, '''8''', '''9''']<br />
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1526
Sortieren
2016-06-25T15:31:53Z
<p>Marius: /* Bubblesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>, <span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1525
Sortieren
2016-06-25T15:31:28Z
<p>Marius: /* Bubblesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>,<span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1524
Sortieren
2016-06-25T15:31:10Z
<p>Marius: /* Sortieralgoritmen */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach '''n''' Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
Beispiel:<br />
<br />
''[5, 4, 1, 8, 0, 2, 6, 9, 7, 3]''<br />
<br />
[<span style="color:red>'''4'''</span>,<span style="color:red>'''5'''</span>, 1, 8, 0, 2, 6, 9, 7, 3]<br />
[4, <span style="color:red>'''1'''</span>, <span style="color:red>'''5'''</span>, 8, 0, 2, 6, 9, 7, 3]<br />
[4, 1, 5, <span style="color:red>'''0'''</span>, <span style="color:red>'''8'''</span>, 2, 6, 9, 7, 3]<br />
[4, 1, 5, 0, <span style="color:red>'''2'''</span>,<span style="color:red> '''8'''</span>, 6, 9, 7, 3]<br />
[4, 1, 5, 0, 2, <span style="color:red>'''6'''</span>, <span style="color:red>'''8'''</span>, 9, 7, 3]<br />
[4, 1, 5, 0, 2, 6, 8, <span style="color:red>'''7'''</span>, <span style="color:red>'''9'''</span>, 3]<br />
[4, 1, 5, 0, 2, 6, 8, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''9'''</span>]<br />
[<span style="color:red>'''1'''</span>, <span style="color:red>'''4'''</span>, 5, 0, 2, 6, 8, 7, 3, 9]<br />
[1, 4, <span style="color:red>'''0'''</span>, <span style="color:red>'''5'''</span>, 2, 6, 8, 7, 3, 9]<br />
[1, 4, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''5'''</span>, 6, 8, 7, 3, 9]<br />
[1, 4, 0, 2, 5, 6, <span style="color:red>'''7'''</span>, <span style="color:red>'''8'''</span>, 3, 9]<br />
[1, 4, 0, 2, 5, 6, 7, <span style="color:red>'''3'''</span>, <span style="color:red>'''8'''</span>, 9]<br />
[1, <span style="color:red>'''0'''</span>, <span style="color:red>'''4'''</span>, 2, 5, 6, 7, 3, 8, 9]<br />
[1, 0, <span style="color:red>'''2'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 3, 8, 9]<br />
[1, 0, 2, 4, 5, 6, <span style="color:red>'''3'''</span>, <span style="color:red>'''7'''</span>, 8, 9]<br />
[<span style="color:red>'''0'''</span>, <span style="color:red>'''1'''</span>, 2, 4, 5, 6, 3, 7, 8, 9]<br />
[0, 1, 2, 4, 5, <span style="color:red>'''3'''</span>,<span style="color:red> '''6'''</span>, 7, 8, 9]<br />
[0, 1, 2, 4, <span style="color:red>'''3'''</span>, <span style="color:red>'''5'''</span>, 6, 7, 8, 9]<br />
[0, 1, 2, <span style="color:red>'''3'''</span>, <span style="color:red>'''4'''</span>, 5, 6, 7, 8, 9]<br />
<br />
''[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]''<br />
<br />
<br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
Beispiel:<br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1488
Sortieren
2016-06-10T10:00:33Z
<p>Marius: /* Mergesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
<br />
public static void Mergesort(int[] a){<br />
<br />
int[] hilfsarr = new int[a.length];<br />
<br />
doMergesort(a, hilfsarr, 0, a.length-1);<br />
<br />
}<br />
<br />
<br />
private static void doMergesort(int[] a, int[] hilfsarr, int links, int rechts){<br />
<br />
// Überprüfung, ob der linke Index kleiner als der rechte Index ist, ansonsten ist das Array sortiert <br />
if ( links < rechts){<br />
<br />
// Emittlung des Index des Elements, welches die Mitte ist<br />
int mitte = links + (rechts - links) / 2;<br />
<br />
// Sortiere die linke Hälfte<br />
doMergesort(a, hilfsarr, links, mitte);<br />
<br />
// Sortiere die rechts Hälfte<br />
doMergesort(a, hilfsarr, mitte + 1, rechts);<br />
<br />
// "Verschmelze" (engl. merge) die beiden sortierten Hälten<br />
merge(a, hilfsarr, links, mitte, rechts);<br />
<br />
<br />
}<br />
}<br />
<br />
<br />
private static void merge(int[] a, int[] hilfsarr, int links, int mitte, int rechts){<br />
<br />
// Kopiere linke und rechte Hälfte in ein Hilfsarray<br />
for (int i = links; i <= rechts; i++){<br />
hilfsarr[i] = a[i];<br />
}<br />
<br />
int i = links;<br />
int j = mitte + 1;<br />
int k = links;<br />
<br />
// Kopiere die kleinsten Werte entweder von der linken Seite oder vom der rechten Seite zurück in das Ursprungsarray <br />
while (i <= mitte && j <= rechts) {<br />
if (hilfsarr[i] <= hilfsarr[j]){<br />
a[k] = hilfsarr[i];<br />
i++;<br />
}<br />
else {<br />
a[k] = hilfsarr[j];<br />
j++;<br />
}<br />
k++;<br />
}<br />
<br />
// Kopiere den Rest der linken Seite in das Ursprungsarray <br />
while (i <= mitte){<br />
a[k] = hilfsarr[i];<br />
k++;<br />
i++;<br />
}<br />
}<br />
<br />
<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1458
Sortieren
2016-06-08T16:04:26Z
<p>Marius: /* Insertionsort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
public static void Insertionsort(int[] A) {<br />
for (int i = 0; i < A.length-1; i++){<br />
for (int j = i+1; j < A.length; j++){<br />
if (A[i] > A[j]){<br />
int swap = A[i];<br />
A[i] = A[j];<br />
A[j] = A[i];<br />
}<br />
}<br />
}<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1457
Sortieren
2016-06-08T16:00:00Z
<p>Marius: /* Bubblesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for( int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
Insertionsort(int[] A)<br />
for (int i = 1; i < A.length; i++){<br />
int insort = A[i];<br />
int j = i;<br />
while (j > 1 && A[i-j] > insort){<br />
A[j] = A[j-1];<br />
j--;<br />
}<br />
A[j] = insort;<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1456
Sortieren
2016-06-08T15:59:30Z
<p>Marius: /* Bubblesort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
public static void bubbleSort(int[] A){<br />
for(int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
Insertionsort(int[] A)<br />
for (int i = 1; i < A.length; i++){<br />
int insort = A[i];<br />
int j = i;<br />
while (j > 1 && A[i-j] > insort){<br />
A[j] = A[j-1];<br />
j--;<br />
}<br />
A[j] = insort;<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1455
Sortieren
2016-06-08T15:58:25Z
<p>Marius: /* Heapsort */</p>
<hr />
<div>Das '''Sortieren''' ist ein Standardproblem der Informatik.<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das '''Bubblesort'''-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld vollständig sortiert. Bei diesem Verfahren wird in jedem Schritt jedes Element mindestens ein Mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
bubbleSort(int[] A){<br />
for(int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im '''Heapsort''' wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten [[Heap]] das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das Wiederherstellen eines Heaps geht relativ schnell.<br />
<br />
<source lang="java"><br />
<br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, 0, i);<br />
heapify(a, 0, i-1);<br />
}<br />
}<br />
<br />
private static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2); i >= 0; i--) {<br />
heapify(a, i, a.length-1);<br />
}<br />
}<br />
<br />
<br />
<br />
private static void heapify(int[] a, int aktKnoten, int anzahlKnoten) {<br />
<br />
int lsNr = 2*aktKnoten+1, //Nummer des linken Sohns<br />
rsNr = lsNr+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (a[lsNr] < a[aktKnoten]) {<br />
tausche(a, lsNr, aktKnoten);<br />
}<br />
}<br />
else {<br />
if (rsNr <= anzahlKnoten) {<br />
selSohn = (a[lsNr] < a[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (a[selSohn] < a[aktKnoten]) { //Heap-Bedingung verletzt<br />
tausche(a, aktKnoten, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
}<br />
<br />
<br />
private static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim '''Insertionsort''' (Einfügesortieren) wird versucht, ein Element in der passenden Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Verschiebung erfordert, bieten sich [[Liste]]n zur Implementierung hier besser an. Damit kann das Einfügen an eine gewisse Position viel einfacher erfolgen.<br />
<br />
<source lang="java"><br />
Insertionsort(int[] A)<br />
for (int i = 1; i < A.length; i++){<br />
int insort = A[i];<br />
int j = i;<br />
while (j > 1 && A[i-j] > insort){<br />
A[j] = A[j-1];<br />
j--;<br />
}<br />
A[j] = insort;<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines [[Teile und herrsche]]-Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
'''Quicksort''' ist das zweite übliche Beispiel für '''Teile und Herrsche-Sortieralgorithmen'''. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größeren rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind. Also wird rekursiv nach demselben Muster vorgegangen: Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der Größe 1 aufgeteilt wurde. Diese sind alle sortiert, somit auch die größeren Teilfelder und damit das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1387
Sortieren
2016-05-22T17:50:51Z
<p>Marius: /* Heapsort */</p>
<hr />
<div>Das Sortieren ist ein Standardproblem der Informatik<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das Bubblesort-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld insbesondere vollständig sortiert. Jedoch wird bei diesem Verfahren in jedem Schritt jedes Element mindestens ein mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
bubbleSort(int[] A){<br />
for(int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im Heapsort wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten Heap das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das wiederherstellen eines Heaps geht dabei relativ schnell.<br />
<br />
<source lang="java"><br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, i, 0);<br />
heapify(a, 0, i);<br />
}<br />
}<br />
<br />
public static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2) - 1; i >= 0; i--) {<br />
heapify(a, i, a.length);<br />
}<br />
}<br />
<br />
public static void heapify(int[] a, int k, int anzahlKnoten) {<br />
int lsNr = 2*k, //Nummer des linken Sohns<br />
rsNr = 2*k+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (heapFeld[lsNr] < heapFeld[k] {<br />
tausche(a, k, lsNr);<br />
}<br />
}<br />
else if (rsNr <= anzahlKnoten) {<br />
selSohn = (heapFeld[lsNr] < heapFeld[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (heapFeld[selSohn] < heapFeld[k]) { //Heap-Bedingung verletzt<br />
tausche(a, k, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
<br />
<br />
public static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim Insertionsort (Einfügesortieren) wird versucht, ein Element an die passende Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Veschiebung erfordert, bieten sich Listen zur Implementierung hier besser an, da das Einfügen an eine gewisse Position viel einfacher erfolgen kann.<br />
<br />
<source lang="java"><br />
Insertionsort(int[] A)<br />
for (int i = 1; i < A.length; i++){<br />
int insort = A[i];<br />
int j = i;<br />
while (j > 1 && A[i-j] > insort){<br />
A[j] = A[j-1];<br />
j--;<br />
}<br />
A[j] = insort;<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines Teile und Herrsche Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
Quicksort ist das zweite übliche Beispiel für Teile und Herrsche Sortieralgorithmen. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größer rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind, aber wenn sie sortiert wären, wäre auch das Gesamtfeld sortiert. Also geht man rekursiv nach dem selben Muster vor. Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der größe 1 aufgeteilt wurde. Diese sind jedoch alle sortiert, also auch die größeren Teilfelder, also das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Sortieren&diff=1386
Sortieren
2016-05-22T17:50:23Z
<p>Marius: /* Heapsort */</p>
<hr />
<div>Das Sortieren ist ein Standardproblem der Informatik<br />
<br />
=Sortieralgoritmen=<br />
<br />
==Bubblesort==<br />
<br />
Das Bubblesort-Sortierverfahren versucht in jeder Iteration das größte Element an das Ende des Feldes zu bewegen. Somit besteht das Ende des Feldes immer aus einem sortierten Teilfeld. Nach $n$ Durchläufen ist damit das Feld insbesondere vollständig sortiert. Jedoch wird bei diesem Verfahren in jedem Schritt jedes Element mindestens ein mal mit einem anderen verglichen.<br />
<br />
<source lang="java"><br />
bubbleSort(int[] A){<br />
for(int n = A.length; n > 1; n--) {<br />
for (int i = 0; i < n-1; i++) {<br />
if (A[i] > A[i+1]){<br />
int swap = A[i];<br />
A[i] = A[i+1];<br />
A[i+1] = swap;<br />
}<br />
}<br />
}<br />
<br />
</source><br />
<br />
==Heapsort==<br />
<br />
<br />
Im Heapsort wird sich die Eigenschaft zu Nutze gemacht, dass in einem korrekten Heap das kleinste Element immer in der Wurzel des Heaps steht. Wird dieses entfernt und im neuen Baum die Heapstruktur wiederhergestellt, lässt sich das Feld sortieren. Das wiederherstellen eines Heaps geht dabei relativ schnell.<br />
<br />
<source lang="java"><br />
public static void heapSort(int[] a) {<br />
generateMaxHeap(a);<br />
for( int i = a.length - 1; i > 0; i--) {<br />
tausche(a, i, 0);<br />
heapify(a, 0, i);<br />
}<br />
}<br />
<br />
public static void generateMaxHeap(int[] a) {<br />
for(int i = (a.length / 2) - 1; i >= 0; i--) {<br />
heapify(a, i, a.length);<br />
}<br />
}<br />
<br />
public static void heapify(int[] a, int k, int anzahlKnoten) {<br />
int lsNR = 2*k, //Nummer des linken Sohns<br />
rsNR = 2*k+1, //Nummer des rechten Sohns<br />
selSohn; //Nummer des selektierten Sohns<br />
<br />
if (lsNr <= anzahlKnoten && rsNr > anzahlKnoten) { //es gibt keinen rechten Sohn<br />
if (heapFeld[lsNr] < heapFeld[k] {<br />
tausche(a, k, lsNr);<br />
}<br />
}<br />
else if (rsNr <= anzahlKnoten) {<br />
selSohn = (heapFeld[lsNr] < heapFeld[rsNr] ? lsNr : rsNr);<br />
// Wähle den Sohn mit der kleineren Markierung aus.<br />
// Bei Gleichheit wähle den rechten Sohn.<br />
<br />
if (heapFeld[selSohn] < heapFeld[k]) { //Heap-Bedingung verletzt<br />
tausche(a, k, selSohn);<br />
heapify(a, selSohn, anzahlKnoten);<br />
}<br />
}<br />
}<br />
<br />
<br />
public static void tausche(int[] a, int i, int j){<br />
int swap = a[i];<br />
a[i] = a[j];<br />
a[j] = swap;<br />
}<br />
<br />
</source><br />
<br />
==Insertionsort==<br />
<br />
Beim Insertionsort (Einfügesortieren) wird versucht, ein Element an die passende Stelle eines bereits sortierten Teilfeldes ''einzufügen'' und den Rest des Feldes dabei zu "verschieben". Da dieses Verfahren bei Feldern viel Aufwand während der Veschiebung erfordert, bieten sich Listen zur Implementierung hier besser an, da das Einfügen an eine gewisse Position viel einfacher erfolgen kann.<br />
<br />
<source lang="java"><br />
Insertionsort(int[] A)<br />
for (int i = 1; i < A.length; i++){<br />
int insort = A[i];<br />
int j = i;<br />
while (j > 1 && A[i-j] > insort){<br />
A[j] = A[j-1];<br />
j--;<br />
}<br />
A[j] = insort;<br />
}<br />
</source><br />
<br />
==Mergesort==<br />
<br />
Mergesort ist das klassische Beispiel eines Teile und Herrsche Algorithmus.<br />
<br />
<source lang="java"><br />
public static void sort(int[] a){<br />
if( a.length > 1) {<br />
int mitte = arry.length / 2;<br />
<br />
int[] links = new int[mitte];<br />
for (int i = 0; i <= links.length - 1; i++) {<br />
links[i] = a[i];<br />
}<br />
<br />
int[] rechts = new int[a.length - mitte];<br />
for (int i = mitte; i <= a.length - 1; i++) {<br />
rechts[i - mitte] = a[i];<br />
}<br />
<br />
sort(links);<br />
sort(rechts);<br />
<br />
a = merge(links, rechts);<br />
}<br />
}<br />
<br />
public static int[] merge(int[] links, int[] rechts){<br />
int[] ErgArray = new int[links.length + rechts.length];<br />
int indexLinks = 0,<br />
indexRechts = 0,<br />
indexErg = 0;<br />
<br />
while (indexLinks < links.length && indexRechts < rechts.length) {<br />
if (links[indexLinks] < rechts[indexRechts]) {<br />
ErgArray[indexErg] = links[indexLinks];<br />
indexLinks++;<br />
} else {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
}<br />
indexErg++;<br />
}<br />
<br />
while (indexLinks < links.length) {<br />
ErgArray[indexerg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
while (indexRechts < rechts.length) {<br />
ErgArray[indexErg] = rechts[indexRechts];<br />
indexRechts++;<br />
indexErg++;<br />
}<br />
<br />
return ErgArray;<br />
}<br />
</source><br />
<br />
==Quicksort==<br />
<br />
Quicksort ist das zweite übliche Beispiel für Teile und Herrsche Sortieralgorithmen. In ihm wird anhand eines arbiträr (willkürlich) gewählten Wertes (meistens das mittlere) das Feld vorsortiert: Alle Elemente kleiner als das gewählte Element werden links davon einsortiert, alle größer rechts davon. Damit hat man zwei Teilfelder, die selbst nicht sortiert sind, aber wenn sie sortiert wären, wäre auch das Gesamtfeld sortiert. Also geht man rekursiv nach dem selben Muster vor. Die beiden kleineren Teilfelder werden wieder arbiträr nach einem Element aufgeteilt und in zwei grob sortierte Teilstrukturen aufgeteilt. Dies geschieht so lange, bis das Feld in Teilfelder der größe 1 aufgeteilt wurde. Diese sind jedoch alle sortiert, also auch die größeren Teilfelder, also das ganze Feld. <br />
<br />
<source lang="java"><br />
public static void quicksort(int[] arr, int links, int rechts) {<br />
if (arr == null || arr.length == 0) {<br />
return;<br />
}<br />
<br />
if (links >= rechts) {<br />
return;<br />
}<br />
<br />
int mitte = links + (rechts - links) / 2;<br />
int pivot = arr[middle];<br />
int i = links, j = rechts;<br />
<br />
while (i <= j) {<br />
while (arr[i] < pivot) {<br />
i++;<br />
}<br />
<br />
while (arr[j] > pivot) {<br />
j--;<br />
}<br />
<br />
if (i <= j) {<br />
int swap = arr[i];<br />
arr[i] = arr[j];<br />
arr[j] = swap;<br />
i++;<br />
j--;<br />
}<br />
}<br />
<br />
if (links < j){<br />
quickSort(arr, low, j);<br />
}<br />
<br />
if (rechts > i){<br />
quickSort(arr, i, rechts);<br />
}<br />
} <br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1302
Glossar (alphabetisch)
2016-05-08T16:05:56Z
<p>Marius: </p>
<hr />
<div>''!! alphabetisch einsortiert, verlinken !!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Klasse<br />
*Klassenatribute/-methoden<br />
*Klassendefinition<br />
*Knoten<br />
*Kommunikation über Parameter<br />
*Kommunikationsprotokoll<br />
*Konstante<br />
*konstruierter, komplexer Datentyp<br />
*Konstruktor<br />
*Kontrollstruktur<br />
*Kreuzprodukt<br />
*Kurzformen<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Schlangen (queue)<br />
*Schleife<br />
*Schlüsselwörter<br />
*Semantik<br />
*Sequentieller Algorithmus<br />
*Sequenz<br />
*Short<br />
*Software<br />
*Sortieralgorithmen<br />
*Sortieren<br />
*Speicher<br />
*Speicheraddresse<br />
*Spezialisierung<br />
*Spezifikation<br />
*Stack<br />
*Standardformate<br />
*Steuerzeichen<br />
*Streng getypte Sprache<br />
*String<br />
*Subklasse<br />
*Suchen<br />
*Superklasse<br />
*switch<br />
*Syntax<br />
*Syntaxdiagramm<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Terminierung<br />
*Terminierungsbedingung<br />
*Testklasse<br />
*Texte (Darstellung)<br />
*this<br />
*Tiefendurchlauf<br />
*top-down Entwurf<br />
*Türme von Hanoi<br />
*Typkomplexität<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Variable<br />
*Variablenparameter<br />
*Vektor / Matrix<br />
*Vektorgrafik<br />
*verbale Semantik<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Verifikation (bzgl. Klassen)<br />
*Verschmelzen<br />
*Verwaltungsinformation<br />
*Virtuelle Maschine<br />
*Vollständige Induktion<br />
*Vorbedignung<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorzeichenbetragszahlen<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1301
Glossar (alphabetisch)
2016-05-08T16:04:54Z
<p>Marius: /* K */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Klasse<br />
*Klassenatribute/-methoden<br />
*Klassendefinition<br />
*Knoten<br />
*Kommunikation über Parameter<br />
*Kommunikationsprotokoll<br />
*Konstante<br />
*konstruierter, komplexer Datentyp<br />
*Konstruktor<br />
*Kontrollstruktur<br />
*Kreuzprodukt<br />
*Kurzformen<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Schlangen (queue)<br />
*Schleife<br />
*Schlüsselwörter<br />
*Semantik<br />
*Sequentieller Algorithmus<br />
*Sequenz<br />
*Short<br />
*Software<br />
*Sortieralgorithmen<br />
*Sortieren<br />
*Speicher<br />
*Speicheraddresse<br />
*Spezialisierung<br />
*Spezifikation<br />
*Stack<br />
*Standardformate<br />
*Steuerzeichen<br />
*Streng getypte Sprache<br />
*String<br />
*Subklasse<br />
*Suchen<br />
*Superklasse<br />
*switch<br />
*Syntax<br />
*Syntaxdiagramm<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Terminierung<br />
*Terminierungsbedingung<br />
*Testklasse<br />
*Texte (Darstellung)<br />
*this<br />
*Tiefendurchlauf<br />
*top-down Entwurf<br />
*Türme von Hanoi<br />
*Typkomplexität<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Variable<br />
*Variablenparameter<br />
*Vektor / Matrix<br />
*Vektorgrafik<br />
*verbale Semantik<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Verifikation (bzgl. Klassen)<br />
*Verschmelzen<br />
*Verwaltungsinformation<br />
*Virtuelle Maschine<br />
*Vollständige Induktion<br />
*Vorbedignung<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorzeichenbetragszahlen<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1300
Glossar (alphabetisch)
2016-05-08T16:03:16Z
<p>Marius: /* V */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Schlangen (queue)<br />
*Schleife<br />
*Schlüsselwörter<br />
*Semantik<br />
*Sequentieller Algorithmus<br />
*Sequenz<br />
*Short<br />
*Software<br />
*Sortieralgorithmen<br />
*Sortieren<br />
*Speicher<br />
*Speicheraddresse<br />
*Spezialisierung<br />
*Spezifikation<br />
*Stack<br />
*Standardformate<br />
*Steuerzeichen<br />
*Streng getypte Sprache<br />
*String<br />
*Subklasse<br />
*Suchen<br />
*Superklasse<br />
*switch<br />
*Syntax<br />
*Syntaxdiagramm<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Terminierung<br />
*Terminierungsbedingung<br />
*Testklasse<br />
*Texte (Darstellung)<br />
*this<br />
*Tiefendurchlauf<br />
*top-down Entwurf<br />
*Türme von Hanoi<br />
*Typkomplexität<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Variable<br />
*Variablenparameter<br />
*Vektor / Matrix<br />
*Vektorgrafik<br />
*verbale Semantik<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Verifikation (bzgl. Klassen)<br />
*Verschmelzen<br />
*Verwaltungsinformation<br />
*Virtuelle Maschine<br />
*Vollständige Induktion<br />
*Vorbedignung<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorzeichenbetragszahlen<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1299
Glossar (alphabetisch)
2016-05-08T16:01:24Z
<p>Marius: /* T */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Schlangen (queue)<br />
*Schleife<br />
*Schlüsselwörter<br />
*Semantik<br />
*Sequentieller Algorithmus<br />
*Sequenz<br />
*Short<br />
*Software<br />
*Sortieralgorithmen<br />
*Sortieren<br />
*Speicher<br />
*Speicheraddresse<br />
*Spezialisierung<br />
*Spezifikation<br />
*Stack<br />
*Standardformate<br />
*Steuerzeichen<br />
*Streng getypte Sprache<br />
*String<br />
*Subklasse<br />
*Suchen<br />
*Superklasse<br />
*switch<br />
*Syntax<br />
*Syntaxdiagramm<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Terminierung<br />
*Terminierungsbedingung<br />
*Testklasse<br />
*Texte (Darstellung)<br />
*this<br />
*Tiefendurchlauf<br />
*top-down Entwurf<br />
*Türme von Hanoi<br />
*Typkomplexität<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1298
Glossar (alphabetisch)
2016-05-08T15:59:51Z
<p>Marius: /* S */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Schlangen (queue)<br />
*Schleife<br />
*Schlüsselwörter<br />
*Semantik<br />
*Sequentieller Algorithmus<br />
*Sequenz<br />
*Short<br />
*Software<br />
*Sortieralgorithmen<br />
*Sortieren<br />
*Speicher<br />
*Speicheraddresse<br />
*Spezialisierung<br />
*Spezifikation<br />
*Stack<br />
*Standardformate<br />
*Steuerzeichen<br />
*Streng getypte Sprache<br />
*String<br />
*Subklasse<br />
*Suchen<br />
*Superklasse<br />
*switch<br />
*Syntax<br />
*Syntaxdiagramm<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1297
Glossar (alphabetisch)
2016-05-08T15:56:23Z
<p>Marius: /* R */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Rastergrafik<br />
*Raumkomplexität<br />
*Rechensysteme<br />
*Rechner<br />
*Referenzen<br />
*Rekursive Funktion<br />
*Relation<br />
*Repräsentation (von Daten)<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1296
Glossar (alphabetisch)
2016-05-08T15:55:21Z
<p>Marius: /* P */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Parallele Ausführung<br />
*Parameter<br />
*Parameterübergabe<br />
*Polymorphie<br />
*postorder<br />
*preorder<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*private<br />
*Problembeschreibung<br />
*Problemklasse<br />
*Programm<br />
*Programmierparadigma<br />
*Programmiersprache<br />
*Programmierung<br />
*protected<br />
*Prozedur<br />
*prozedurale (funkt.) Abstraktion<br />
*Pseudocode<br />
*public<br />
*Punkt-Operator<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1295
Glossar (alphabetisch)
2016-05-08T15:37:36Z
<p>Marius: /* I */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Imperative Programmierung<br />
*Implizite Typanpassung<br />
*Informatik<br />
*Informationsverarbeitung<br />
*inorder-Durchlauf<br />
*Initialisierung<br />
*Instanz<br />
*Integer<br />
*Interface<br />
*Internes Sortieren<br />
*Interpretation<br />
*Iteration<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1294
Glossar (alphabetisch)
2016-05-08T15:30:45Z
<p>Marius: /* E */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*E-/A-Medien<br />
*Effizienz<br />
*Ein- und Ausgabe<br />
*Einfache Grundoperationen<br />
*Einfügen<br />
*Einzelproblem<br />
*Elementaroperationen<br />
*Entwurfsmethodik<br />
*extends<br />
*externes Sortieren<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Informatik<br />
*Imperative Programmierung<br />
*Informationsverarbeitung<br />
*Interpretation<br />
*Initialisierung<br />
*Integer<br />
*Implizite Typanpassung<br />
*Iteration<br />
*Internes Sortieren<br />
*Instanz<br />
*Interface<br />
*inorder-Durchlauf<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1293
Glossar (alphabetisch)
2016-05-08T15:28:48Z
<p>Marius: /* D */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*denotationale Semantik<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*doppeltverkettete Liste<br />
*Double<br />
*do-while-Schleife<br />
*Dynamische Datenstruktur<br />
<br />
=E=<br />
<br />
*Einzelproblem<br />
*Effizienz<br />
*Entwurfsmethodik<br />
*E-/A-Medien<br />
*Ein- und Ausgabe<br />
*Elementaroperationen<br />
*Einfache Grundoperationen<br />
*externes Sortieren<br />
*Einfügen<br />
*extends<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Informatik<br />
*Imperative Programmierung<br />
*Informationsverarbeitung<br />
*Interpretation<br />
*Initialisierung<br />
*Integer<br />
*Implizite Typanpassung<br />
*Iteration<br />
*Internes Sortieren<br />
*Instanz<br />
*Interface<br />
*inorder-Durchlauf<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1292
Glossar (alphabetisch)
2016-05-08T15:27:25Z
<p>Marius: /* D */</p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Darstellung ganzer Zahlen<br />
*Darstellung natürlicher Zahlen<br />
*Datenstruktur<br />
*Datentyp<br />
*Datenverarbeitung<br />
*Deklaration<br />
*Determiniertheit<br />
*Determinismus<br />
*Dimensierung<br />
*Double<br />
*Dynamische Datenstruktur<br />
*denotationale Semantik<br />
*do-while-Schleife<br />
*doppeltverkettete Liste<br />
<br />
=E=<br />
<br />
*Einzelproblem<br />
*Effizienz<br />
*Entwurfsmethodik<br />
*E-/A-Medien<br />
*Ein- und Ausgabe<br />
*Elementaroperationen<br />
*Einfache Grundoperationen<br />
*externes Sortieren<br />
*Einfügen<br />
*extends<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Informatik<br />
*Imperative Programmierung<br />
*Informationsverarbeitung<br />
*Interpretation<br />
*Initialisierung<br />
*Integer<br />
*Implizite Typanpassung<br />
*Iteration<br />
*Internes Sortieren<br />
*Instanz<br />
*Interface<br />
*inorder-Durchlauf<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Byte&diff=1215
Byte
2016-04-20T14:28:26Z
<p>Marius: /* Verwendungszweck */</p>
<hr />
<div>Ein '''Byte''' ist sowohl eine [[Bitfolge]] von acht [[Bit | Bits]], als auch der [[primitive Datentyp]] in Java, der genau acht Bit groß ist.<br />
<br />
=Byte als Javadatentyp=<br />
<br />
==Aufbau==<br />
<br />
<source lang= "java"><br />
byte Name = Zahl;<br />
</source><br />
<br />
===Schlüsselwort===<br />
*byte<br />
<br />
===Verwendungszweck===<br />
Byte wird verwendet, um sehr kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -128 bis 127. Ansonsten verhält sich byte wie [[Short | short]], [[Integer | int]] oder [[Long | long]], benötigen jedoch 8 Bit Speicherplatz.<br />
<br />
==Beispiele==<br />
<br />
<source lang= "java"><br />
byte Zahl1 = 50;<br />
short Zahl2 = -73;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Byte&diff=1214
Byte
2016-04-20T14:27:56Z
<p>Marius: </p>
<hr />
<div>Ein '''Byte''' ist sowohl eine [[Bitfolge]] von acht [[Bit | Bits]], als auch der [[primitive Datentyp]] in Java, der genau acht Bit groß ist.<br />
<br />
=Byte als Javadatentyp=<br />
<br />
==Aufbau==<br />
<br />
<source lang= "java"><br />
byte Name = Zahl;<br />
</source><br />
<br />
===Schlüsselwort===<br />
*byte<br />
<br />
===Verwendungszweck===<br />
Short wird verwendet, um sehr kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -128 bis 127. Ansonsten verhält sich byte wie [[Short | short]], [[Integer | int]] oder [[Long | long]], benötigen jedoch 8 Bit Speicherplatz.<br />
<br />
==Beispiele==<br />
<br />
<source lang= "java"><br />
byte Zahl1 = 50;<br />
short Zahl2 = -73;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Short&diff=1213
Short
2016-04-20T14:26:19Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
short Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
*short<br />
<br />
==Verwendungszweck==<br />
Short wird verwendet, um kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -32.768 bis 32.767. Ansonsten verhält sich short wie [[Byte | byte]], [[Integer | int]] oder [[Long | long]], benötigt jedoch 16 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<br />
<source lang= "java"><br />
short Zahl1 = 50;<br />
short Zahl2 = -7000;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Double&diff=1212
Double
2016-04-20T14:22:56Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
double Name = Kommazahl oder Zahl mit einem abschließendem D oder d;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*double<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ Double wird verwendet um Gleitkommazahlen zu speichern. Der Wertebereich liegt bei +/-4,9*10<sup>-324</sup> bis +/-1,7*10<sup>+308. Es werden 64 Bit SPeicherplatz benötigt. Double wegen ihrer doppelten Genauigkeit im Vergleich zu float eher verwendet. Eine Zahl wird vom Compiuler als double interpretiert, wenn sie eine Kommazahl ist oder wenn ein D oder d an eiejnr Zahl angefügt wird. Der Buchstaben E (oder e) kann als Exponet verwendet werden. xEy entspricht x*10<sup>y</sup>. <br />
=Beispiele=<br />
<source lang = "java"><br />
double Zahl1 = 500.0154;<br />
double Zahl2 = -1337D;<br />
double Zahl3 = 3.14E5;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Float&diff=1211
Float
2016-04-20T14:19:39Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
float Name = (Komma-)Zahl mit einem abschließendem F oder f;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*float<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ Float wird verwendet um Gleitkommazahlen zu speichern. Der Wertebereich liegt bei +/- 1,4*10<sup>-45</sup> bis +/-3,4*10<sup>+38</sup>. Es werden 32 Bit Speicherpaltz benötigt. Der Typ Float wird wegen seiner Ungenauigkeit seltener verwendet als der artverwandte Typ [[Double| double]]. Werte von Float-Variablen müssen expliziet mit F oder f angegeben werden, ansonsten werden diese als double interpretiert. Der Buchstaben E (oder e) kann als Exponet verwendet werden. xEy entspricht x*10<sup>y</sup>. <br />
=Beispiele=<br />
<source lang = "java"><br />
float Zahl1 = 500.0154F;<br />
float Zahl2 = -1337F;<br />
float Zahl3 = 3.14E5F;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Float&diff=1210
Float
2016-04-20T14:14:37Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
float Name = (Komma-)Zahl mit einem abschließendem F oder f;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*float<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ Float wird verwendet um Gleitkommazahlen zu speichern. Der Wertebereich liegt bei +/- 1,4*10<sup>-45</sup> bis +/-3,4*10<sup>+38</sup>. Der Typ Float wird wegen seiner Ungenauigkeit seltener verwendet als der artverwandte Typ [[Double| double]]. Werte von Float-Variablen müssen expliziet mit F oder f angegeben werden, ansonsten werden diese als double interpretiert. Der Buchstaben E (oder e) kann als Exponet verwendet werden. xEy entspricht x*10<sup>y</sup>. <br />
=Beispiele=<br />
<source lang = "java"><br />
float Zahl1 = 500.0154LF;<br />
float Zahl2 = -1337F;<br />
float Zahl3 = 3.14E5F;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Long&diff=1209
Long
2016-04-20T14:10:34Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
long Name = Zahl mit einem abschließendem L oder l;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*long<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ long wird verwendet um ganze Zahlen zu speichern. Der Wertebereich liegt bei -2<sup>63</sup> bis 2<sup>63</sup>-1. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] oder [[Integer| int]], benötigen jedoch 64 bit Speicherplatz. Zahlenwerte einer Longvariablen müssen expliziet mit L oder l angegeben werden, ansonsten werden die Werte als integer verwedendet, was zu Fehlern führen kann.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
long Zahl1 = 500L;<br />
long Zahl2 = -1337L;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Long&diff=1208
Long
2016-04-20T13:44:16Z
<p>Marius: /* Verwendungszweck */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
long Name = Zahl mit einem abschließendem L oder l;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*long<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ long wird verwendet um ganze Zahlen zu speichern. Der Wertebereich liegt bei -2<sup>63</sup> bis 2<sup>63</sup>-1. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] oder [[Integer| int]], benötigen jedoch 64 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
long Zahl1 = 500L;<br />
long Zahl2 = -1337L;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Integer&diff=1207
Integer
2016-04-20T13:44:06Z
<p>Marius: /* Verwendungszweck */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
int Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*int<br />
<br />
==Verwendungszweck==<br />
<br />
Integer werden verwendet um ganze Zahlen zu speichern. Der Typ Integer wird dabei am meisten benutzt. Der Wertebereich liegt bei -2.147.483.648 bis 2.147.483.647. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] oder [[Long | long]], benötigen jedoch 32 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
int Zahl1 = 500;<br />
int Zahl2 = -1337;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Long&diff=1206
Long
2016-04-20T13:43:48Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
long Name = Zahl mit einem abschließendem L oder l;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*long<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ long wird verwendet um ganze Zahlen zu speichern. Der Wertebereich liegt bei -2<sup>63</sup> bis 2<sup>63</sup>-1. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] und [[Integer| int]], benötigen jedoch 64 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
long Zahl1 = 500L;<br />
long Zahl2 = -1337L;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Long&diff=1205
Long
2016-04-20T13:42:58Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
long Name = Zahl mit einem abschließendem L oder l;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*long<br />
<br />
==Verwendungszweck==<br />
<br />
Der Typ long wird verwendet um ganze Zahlen zu speichern. Der Wertebereich liegt bei -2<sup>63</sup> bis 2<sup>63</sup>-1. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] und [[Long | long]], benötigen jedoch 64 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
long Zahl1 = 500L;<br />
long Zahl2 = -1337L;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Integer&diff=1204
Integer
2016-04-20T13:37:17Z
<p>Marius: /* Beispiele */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
int Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*int<br />
<br />
==Verwendungszweck==<br />
<br />
Integer werden verwendet um ganze Zahlen zu speichern. Der Typ Integer wird dabei am meisten benutzt. Der Wertebereich liegt bei -2.147.483.648 bis 2.147.483.647. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] und [[Long | long]], benötigen jedoch 32 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source lang = "java"><br />
int Zahl1 = 500;<br />
int Zahl2 = -1337;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Integer&diff=1203
Integer
2016-04-20T13:36:47Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
int Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
*int<br />
<br />
==Verwendungszweck==<br />
<br />
Integer werden verwendet um ganze Zahlen zu speichern. Der Typ Integer wird dabei am meisten benutzt. Der Wertebereich liegt bei -2.147.483.648 bis 2.147.483.647. Integer verhalten sich genau so wie [[Byte |byte]], [[Short | short]] und [[Long | long]], benötigen jedoch 32 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<source int = "java"><br />
int Zahl1 = 500;<br />
int Zahl2 = -1337;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Short&diff=1202
Short
2016-04-20T13:29:03Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
short Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
*short<br />
<br />
==Verwendungszweck==<br />
Short wird verwendet, um kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -32.768 bis 32.767. Ansonsten verhalten sich short wie [[Byte | byte]], [[Integer | int]] oder [[Long | long]], benötigen aber 16 bit Speicherplatz.<br />
<br />
=Beispiele=<br />
<br />
<source lang= "java"><br />
short Zahl1 = 50;<br />
short Zahl2 = -7000;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Short&diff=1201
Short
2016-04-20T13:10:01Z
<p>Marius: /* Verwendungszweck */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
short Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
*short<br />
<br />
==Verwendungszweck==<br />
Short wird verwendet, um kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -32.768 bis 32.767. Ansonsten verhalten sich short wie [[Byte | byte]], [[Integer | int]] oder [[Long | long]].<br />
<br />
=Beispiele=<br />
<br />
<source lang= "java"><br />
short Zahl1 = 50;<br />
short Zahl2 = -7000;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Short&diff=1200
Short
2016-04-20T13:09:48Z
<p>Marius: /* Verwendungszweck */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
short Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
*short<br />
<br />
==Verwendungszweck==<br />
Short wird verwendet, um kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -32.768 bis 32.767. Ansonsten verhalten sich short wie [[Byte | byte]] [[Integer | int]] oder [[Long | long]].<br />
<br />
=Beispiele=<br />
<br />
<source lang= "java"><br />
short Zahl1 = 50;<br />
short Zahl2 = -7000;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Short&diff=1199
Short
2016-04-20T13:01:46Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang= "java"><br />
short Name = Zahl;<br />
</source><br />
<br />
==Schlüsselwort==<br />
*short<br />
<br />
==Verwendungszweck==<br />
Short wird verwendet, um kleine ganze Zahlen zu speichern. Der Wertebereich leigt bei -32.768 bis 32.767. Ansonsten verhalten sich short wie [[Integer | int]] oder [[Long | long]].<br />
<br />
<br />
=Beispiele=<br />
<br />
<source lang= "java"><br />
short Zahl1 = 50;<br />
short Zahl2 = -7000;<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Character&diff=1198
Character
2016-04-20T12:33:49Z
<p>Marius: </p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang="java"><br />
char Name = Unicodezeichen<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
* char<br />
<br />
==Verwendungszweck==<br />
<br />
Chars werden verwendet um Unicodezeichen im Java-Code zu speichern. Dafür besitzen Chars einen Wertebreich von 0 bis 65.535.<br />
<br />
=Beispiele=<br />
<br />
<source lang="java"><br />
char Zeichen1 = 'a';<br />
char Zeichen2 = '\n';<br />
</source></div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Character&diff=1197
Character
2016-04-20T12:33:36Z
<p>Marius: /* Aufbau */</p>
<hr />
<div>=Aufbau=<br />
<br />
<source lang="java"><br />
char Name = Unicodezeichen<br />
</source><br />
<br />
==Schlüsselwort==<br />
<br />
* char<br />
<br />
==Verwendungszweck==<br />
<br />
Chars werden verwendet um Unicodezeichen im Java-Code zu speichern. Dafür besitzen Chars einen Wertebreich von 0 bis 65.535.<br />
<br />
=Beispiele=<br />
<br />
<source lang="java"><br />
char Zeichen1 = 'a';<br />
char Zeichen2 = '\n';<br />
</source><br />
<br />
=Beispiele=</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Character&diff=1196
Character
2016-04-20T11:57:09Z
<p>Marius: /* Schlüsselwort */</p>
<hr />
<div>=Aufbau=<br />
==Schlüsselwort==<br />
<br />
* char<br />
<br />
==Verwendungszweck==<br />
<br />
=Beispiele=</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Datentyp&diff=1195
Datentyp
2016-04-20T11:43:00Z
<p>Marius: /* Objektdatentypen */</p>
<hr />
<div>'''Datentyp''' ist die Bezeichnung für die Interpretation und Semantik einer Menge von Daten. Zu einem Datentyp gehören Informationen wie Größe, Struktur und erlaubte [[Methode | Methoden]] und [[Operator | Operatoren]].<br />
<br />
Zu den Datentypen in [[Java]] gehört die Unterscheidung von '''primitiven Datentypen''' und '''Objektdatentypen'''.<br />
<br />
= Primitive Datentypen =<br />
<br />
Diese Datentypen werden als primitiv bezeichnet, da sie die grundlegenden Bausteine für andere Datentypen sind. Sie alle repräsentieren numerische Werte.<br />
<br />
Die Größe, Struktur und Interpretation der primitiven Datentypen ist im Java-Standard vorgegeben (siehe: https://de.wikibooks.org/wiki/Java_Standard:_Primitive_Datentypen):<br />
{| class = "wikitable" width=100% align = "center"<br />
! Datentyp!! Größe!! Wertebereich<br />
|-<br />
|[[Boolean | boolean]] || undefiniert|| true / false<br />
|-<br />
|[[Char | char]]|| 16 Bit || 0 ... 65.535<br />
|-<br />
|[[Byte | byte]]|| 8 Bit || -128 ... 127<br />
|-<br />
|[[Short | short]]|| 16 Bit || -32.768 ... 32.767<br />
|-<br />
|[[Integer | int]]|| 32 Bit || -2.147.483.648 ... 2.147.483.647<br />
|-<br />
|[[Long | long]]|| 64 Bit || -2<sup>63</sup> bis 2<sup>63</sup>-1<br />
|-<br />
|[[Float | float]] || 32 Bit || +/- 1,4*10<sup>-45</sup> ... +/-3,4*10<sup>+38</sup><br />
|-<br />
|[[Double | double]] || 64 Bit || +/-4,9*10<sup>-324</sup> ... +/-1,7*10<sup>+308</sup><br />
|}<br />
<br />
Variablen primitiver Datentypen werden beim Aufrufen von Funktionen per [[Call by Value]] übergeben. Das heißt, dass Veränderungen der [[Parametervariable|Parametervariablen]] einer Funktion keinen Einfluss auf die übergebenen Variablen haben.<br />
<br />
= Objektdatentypen =<br />
<br />
Alle nicht primitiven Datentypen werden in Java durch ihre eigene [[Klasse]] definiert. Diese sind daher immer eine Kombination aus diversen primitiven oder anderen Objektdatentypen. Wie diese Daten zusammengesetzt werden und was sie bedeuten, ist im Quellcode zu definieren und zu dokumentieren.<br />
<br />
Zudem gibt es viele nützliche Objektdatentypen in der Java-Standard-Bibliothek (z.B. [[String]] oder [[Array]]), die nicht zusätzlich in das Programm [[Import | importiert]] werden müssen, sondern immer zur Verfügung stehen.<br />
<br />
== Beispiel ==<br />
<br />
Eine Position auf der 2-Dimensionalen Ebene ist durch zwei '''double''' zu repräsentieren. Entsprechend wird dem ersten der '''double''' die Semantik der '''x'''-Koordinate und dem zweiten die Semantik der '''y'''-Koordinate zugewiesen. Dies kann in Java z.B. folgendermaßen geschehen:<br />
<br />
<source lang="java"><br />
public class Coordinate {<br />
public double x;<br />
public double y;<br />
}<br />
</source><br />
<br />
= Datenstrukturen =<br />
<br />
Wie komplexe Datenstrukturen zusammengesetzt und verwendet werden können, findet man in ihren eigenen entsprechenden Artikeln:<br />
<br />
* [[Baum]]<br />
* [[Liste]]<br />
* [[Heap]]<br />
<br />
Die Aufgabe eines Programmierers besteht jedoch meistens darin, aus den verschiedenen Datentypen und anderen Informationen seinen eigenen Datentyp zu basteln, der das Problem und die Lösungswege am besten repräsentiert.</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1115
Glossar (alphabetisch)
2016-04-10T13:45:05Z
<p>Marius: </p>
<hr />
<div>''!! Nur einsortiert, teilweise alphabetisch!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Datenverarbeitung<br />
*Darstellung natürlicher Zahlen<br />
*Darstellung ganzer Zahlen<br />
*Determinismus<br />
*Determiniertheit<br />
*denotationale Semantik<br />
*Deklaration<br />
*Datentyp<br />
*Double<br />
*do-while-Schleife<br />
*Datenstruktur<br />
*Dimensierung<br />
*Dynamische Datenstruktur<br />
*doppeltverkettete Liste<br />
<br />
=E=<br />
<br />
*Einzelproblem<br />
*Effizienz<br />
*Entwurfsmethodik<br />
*E-/A-Medien<br />
*Ein- und Ausgabe<br />
*Elementaroperationen<br />
*Einfache Grundoperationen<br />
*externes Sortieren<br />
*Einfügen<br />
*extends<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Informatik<br />
*Imperative Programmierung<br />
*Informationsverarbeitung<br />
*Interpretation<br />
*Initialisierung<br />
*Integer<br />
*Implizite Typanpassung<br />
*Iteration<br />
*Internes Sortieren<br />
*Instanz<br />
*Interface<br />
*inorder-Durchlauf<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius
https://ls14-eini.cs.tu-dortmund.de/index.php?title=Glossar_(alphabetisch)&diff=1114
Glossar (alphabetisch)
2016-04-10T13:44:39Z
<p>Marius: /* Z */</p>
<hr />
<div>''!! Nur einsortiert, nicht komplett alphabetisch (ab D)!!''<br />
<br />
=A=<br />
<br />
*[[Stack | Abarbeitung von Funktionsaufrufen]]<br />
*[[abstrakte Klasse]]<br />
*[[abstrakte Methode]]<br />
*[[Abstraktion]]<br />
*[[Algorithmus]]<br />
*[[Algemeinheit]]<br />
*[[Array]]<br />
*[[ASCII]]<br />
*[[Attritbut]]<br />
*[[Aufwand]]<br />
*[[Ausdruck]]<br />
*[[AVL-Baum]]<br />
<br />
=B=<br />
<br />
*balancierter Baum<br />
*Bäume<br />
*Bedeutung Gleichzeichen<br />
*bedingte Anweisung<br />
*Bedingung<br />
*Betriebssystem<br />
*binärer Baum<br />
*binärer Suchbaum<br />
*Binärzahlen<br />
*Bit<br />
*Bitfolge<br />
*Blatt<br />
*Block<br />
*Boolean<br />
*Bool'sche Algebra<br />
*break<br />
*Breitendurchlauf<br />
*Byte<br />
*Byte (Javadatentyp)<br />
<br />
=C=<br />
<br />
*call by reference<br />
*call by value<br />
*Char<br />
*Computer<br />
*Compiler<br />
*continue<br />
*CPU<br />
<br />
=D=<br />
<br />
*Datenverarbeitung<br />
*Darstellung natürlicher Zahlen<br />
*Darstellung ganzer Zahlen<br />
*Determinismus<br />
*Determiniertheit<br />
*denotationale Semantik<br />
*Deklaration<br />
*Datentyp<br />
*Double<br />
*do-while-Schleife<br />
*Datenstruktur<br />
*Dimensierung<br />
*Dynamische Datenstruktur<br />
*doppeltverkettete Liste<br />
<br />
=E=<br />
<br />
*Einzelproblem<br />
*Effizienz<br />
*Entwurfsmethodik<br />
*E-/A-Medien<br />
*Ein- und Ausgabe<br />
*Elementaroperationen<br />
*Einfache Grundoperationen<br />
*externes Sortieren<br />
*Einfügen<br />
*extends<br />
<br />
=F=<br />
<br />
*Festpunktzahlen<br />
*final<br />
*Float<br />
*for-Schleife<br />
*Funktion<br />
*Funktionale Programmierung<br />
*funktionslokal<br />
<br />
=G=<br />
<br />
*gerichteter Graph<br />
*ggt nach Euklid<br />
*Gleitpunktzahl<br />
*globale Variablen<br />
*Graph<br />
<br />
=H=<br />
<br />
*Hardware<br />
*Heap<br />
*Heapify<br />
*Heapsort<br />
*Hexadezimalzahlen<br />
<br />
=I=<br />
<br />
*Informatik<br />
*Imperative Programmierung<br />
*Informationsverarbeitung<br />
*Interpretation<br />
*Initialisierung<br />
*Integer<br />
*Implizite Typanpassung<br />
*Iteration<br />
*Internes Sortieren<br />
*Instanz<br />
*Interface<br />
*inorder-Durchlauf<br />
<br />
=J=<br />
<br />
*Java<br />
*Java-Programm<br />
<br />
=K=<br />
<br />
*Kommunikationsprotokoll<br />
*Kreuzprodukt<br />
*Kurzformen<br />
*konstruierter, komplexer Datentyp<br />
*Konstante<br />
*Kontrollstruktur<br />
*Kommunikation über Parameter<br />
*Klasse<br />
*Klassendefinition<br />
*Konstruktor<br />
*Klassenatribute/-methoden<br />
*Knoten<br />
<br />
=L=<br />
<br />
*Laufvariable<br />
*lineare Liste<br />
*Liste<br />
*Logische Programmierung<br />
*Long<br />
<br />
=M=<br />
<br />
*main-Methode<br />
*Maschinensprache<br />
*Mengen<br />
*Methode<br />
*Methodendefinition<br />
<br />
=N=<br />
<br />
*Nachbedingung<br />
*Nebenläufiger Algorithmus<br />
*new-Operator<br />
*Nibble<br />
*null<br />
*Numerik<br />
<br />
=O=<br />
<br />
*O-Notation<br />
*Objekt<br />
*Objektorientierte Programmierung<br />
*Operation<br />
*operationale Semantik<br />
<br />
=P=<br />
<br />
*Problemklasse<br />
*Programmierung<br />
*Programm<br />
*Problembeschreibung<br />
*Pseudocode<br />
*Parallele Ausführung<br />
*Programmiersprache<br />
*Programmierparadigma<br />
*Primitive Datentypen<br />
*Priotitäten von Operatoren<br />
*Prozedur<br />
*Parameter<br />
*prozedurale (funkt.) Abstraktion<br />
*public<br />
*private<br />
*Parameterübergabe<br />
*protected<br />
*Polymorphie<br />
*Punkt-Operator<br />
*preorder<br />
*postorder<br />
<br />
=Q=<br />
<br />
*Quelltext/-code<br />
<br />
=R=<br />
<br />
*Raumkomplexität<br />
*Rechner<br />
*Rechensysteme<br />
*Repräsentation (von Daten)<br />
*Rastergrafik<br />
*Relation<br />
*Robustheit<br />
*Rückgabe<br />
*Rückgabewert<br />
*Rekursive Funktion<br />
*Referenzen<br />
<br />
=S=<br />
<br />
*Syntax<br />
*Semantik<br />
*Sortieren<br />
*Suchen<br />
*Software<br />
*Speicher<br />
*Standardformate<br />
*Spezifikation<br />
*Sequentieller Algorithmus<br />
*Syntaxdiagramm<br />
*Short<br />
*Speicheraddresse<br />
*Steuerzeichen<br />
*String<br />
*Streng getypte Sprache<br />
*Sequenz<br />
*switch<br />
*Schleife<br />
*static<br />
*Stack<br />
*Sortieralgorithmen<br />
*Superklasse<br />
*Subklasse<br />
*Spezialisierung<br />
*Schlangen (queue)<br />
*Schlüsselwörter<br />
<br />
=T=<br />
<br />
*Teile und herrsche<br />
*Texte (Darstellung)<br />
*Terminierung<br />
*Typkomplexität<br />
*top-down Entwurf<br />
*Terminierungsbedingung<br />
*Türme von Hanoi<br />
*Testklasse<br />
*this<br />
*Tiefendurchlauf<br />
<br />
=U=<br />
<br />
*Umrechnungsverfahren<br />
*ungerichtete Graphen<br />
*Unicode<br />
*Unterprogramm<br />
<br />
=V=<br />
<br />
*Verifikation (bzgl. Klassen)<br />
*Virtuelle Maschine<br />
*Vektorgrafik<br />
*Vorzeichenbetragszahlen<br />
*Vorgehensweise (Erstellung eines Programms)<br />
*Vorbedignung<br />
*verbale Semantik<br />
*Variable<br />
*Variablenparameter<br />
*Verwaltungsinformation<br />
*Vektor / Matrix<br />
*Verschmelzen<br />
*Verebung<br />
*Vererbungshierarchie<br />
*Vollständige Induktion<br />
<br />
=W=<br />
<br />
*Wert<br />
*Werteparameter<br />
*while-Schleife<br />
*Wurzel<br />
<br />
=X=<br />
<br />
=Y=<br />
<br />
=Z=<br />
<br />
*Zeitkomplexität<br />
*Zuweisung<br />
*Zuweisung (Array)<br />
*Zweierkomplement</div>
Marius