51 lines
1.5 KiB
C++
51 lines
1.5 KiB
C++
void insertionSortBase(int array[], int array_size, bool asc) {
|
|
int i = 0;
|
|
|
|
// Dieser Loop wird "array_size" (=n) mal ausgeführt.
|
|
while (i < array_size) {
|
|
int j = i;
|
|
// empirisch wird dieser Loop auch n mal ausgeführt
|
|
while (j > 0 && array[j - 1] > array[j]) {
|
|
int currentValue = array[j];
|
|
array[j] = array[j - 1];
|
|
array[j - 1] = currentValue;
|
|
j--;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
// Zusammen ergibt das wieder eine worst case Komplexität von O(n^2)
|
|
|
|
void insertionSortOptimized(int array[], int array_size, bool asc) {
|
|
int i = 0;
|
|
while (i < array_size) {
|
|
int x = array[i];
|
|
int j = i - 1;
|
|
while (j >= 0 && array[j] > x) {
|
|
array[j + 1] = array[j];
|
|
j--;
|
|
}
|
|
array[j + 1] = x;
|
|
i++;
|
|
}
|
|
}
|
|
// Hier werden wieder zwei Schleifen ineinander ausgeführt. Auch wenn die innere
|
|
// Schleife effizienter ist bleibt die Komplexität O(n^2)
|
|
|
|
void insertionSortRecursive(int array[], int array_size, bool asc) {
|
|
// in jedem Rekursionsschritt wird der Algorithmus mit array_size-1
|
|
// aufgerufen, und dann abgebrochen, wenn arraysize=0 ist. D.h. es werden
|
|
// insgesamt n Rekursionsschritte ausgeführt -> O(n)
|
|
if (array_size > 0) {
|
|
insertionSortRecursive(array, array_size - 1, true);
|
|
int x = array[array_size - 1];
|
|
int j = array_size - 2;
|
|
// Diese Schleife kann auch im worst case n mal ausgeführt werden -> O(n)
|
|
while (j >= 0 && array[j] > x) {
|
|
array[j + 1] = array[j];
|
|
j--;
|
|
}
|
|
array[j + 1] = x;
|
|
}
|
|
}
|
|
// Insgesamt: O(n*n) = O(n^2)
|