Blasensortierung ist ein einfacher und intuitiver Sortieralgorithmus. Benachbarte Elemente werden wiederholt vertauscht, wenn sie in der falschen Reihenfolge sind, bis das Array sortiert ist. Bei diesem Algorithmus „blubbert“ das größte Element in jeder Iteration bis zum Ende des Arrays. Die Blasensortierung ist bei großen Datensätzen ineffizient, eignet sich jedoch für Bildungszwecke und kleine Datensätze. In diesem Artikel implementieren wir den Blasensortierungsalgorithmus in der Programmiersprache C.
String vergleichen c#
Der erste Schritt besteht darin, die Blasensortierungsfunktion zu definieren. Diese Funktion verwendet ein ganzzahliges Array und die Größe des Arrays als Parameter. Die Funktion gibt nichts zurück, da sie das ursprüngliche Array ändert. Hier ist das Funktionsdefinition:
void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } </n> Die Funktion hat zwei Schleifen. Die äußere Schleife verläuft vom ersten Element bis zum vorletzten Element des Arrays. Die innere Schleife verläuft vom ersten Element bis zum vorletzten Element des unsortierten Teils des Arrays. Die Bedingung der inneren Schleife ist n – i – 1, da die letzten i Elemente des Arrays bereits sortiert sind.
In jeder Iteration der inneren Schleife vergleichen wir benachbarte Elemente. Wenn das linke Element größer als das rechte Element ist, tauschen wir sie aus. Nach Abschluss der inneren Schleife befindet sich das größte Element garantiert am Ende des unsortierten Teils des Arrays.
Jetzt können wir die Hauptfunktion schreiben, um unsere Blasensortierungsimplementierung zu testen. Hier ist die Hauptfunktion zusammen mit dem vorherigen Teil:
Post-Order-Traversal
C-Programm:
#include void bubble_sort(int arr[], int n) { int i, j; for (i = 0; i <n - 1; i++) { for (j="0;" j <n i j++) if (arr[j]> arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } int main() { int arr[] = {64, 34, 25, 12, 22, 11, 90}; int n = sizeof(arr) / sizeof(arr[0]); bubble_sort(arr, n); printf('Sorted array: '); for (int i = 0; i <n; i++) { printf('%d ', arr[i]); } return 0; < pre> <p>The main function creates an integer array arr of size 7 and initializes it with random numbers. We then calculate the size of the array by dividing the size of the array by the size of an integer element. Next, we call the bubble_sort function to sort the array. Finally, we print the sorted array using a for loop.</p> <p> <strong>When we run the program, we should see the following output:</strong> </p> <pre> Sorted array: 11 12 22 25 34 64 90 </pre> <p>This output shows that our bubble sort implementation correctly sorted the array in ascending order.</p> <p>To run the program, we need to compile it using a C compiler. Here is an example <strong>compilation command for GCC:</strong> </p> <pre> gcc -o bubble_sort bubble_sort.c </pre> <p>This command compiles the bubble_sort.c file and produces an executable file named bubble_sort.</p> <p>In summary, the bubble sort algorithm repeatedly swaps adjacent elements until the array is sorted. The algorithm has a time complexity of O(n<sup>2</sup>), which makes it inefficient for large data sets. However, it is useful for educational purposes and small data sets. We implemented the bubble sort algorithm in C programming language and tested it using a simple example.</p> <h3>Characteristics:</h3> <ul> <li>Bubble sort is a simple sorting algorithm.</li> <li>It works by repeatedly swapping adjacent elements if they are in the wrong order.</li> <li>The algorithm sorts the array in ascending or descending order.</li> <li>It has a time complexity of O(n<sup>2</sup>) in the worst case, where n is the size of the array.</li> </ul> <h3>Usage:</h3> <ul> <li>Bubble sort is useful for educational purposes and small data sets.</li> <li>It is not suitable for large data sets because of its time complexity.</li> </ul> <h3>Advantages:</h3> <ul> <li>Bubble sort is easy to understand and implement.</li> <li>It requires minimal additional memory space to perform the sorting.</li> </ul> <h3>Disadvantages:</h3> <ul> <li>It is not efficient for large data sets because of its time complexity.</li> <li>It has poor performance compared to other sorting algorithms, such as quicksort and mergesort.</li> </ul> <h2>Conclusion:</h2> <p>Bubble sort is a simple and intuitive sorting algorithm that is useful for educational purposes and small data sets. However, its time complexity makes it inefficient for large data sets. Therefore, it is not commonly used in real-world applications. Other sorting algorithms, such as quicksort and mergesort, are more efficient for large data sets.</p> <hr></n;></n> Diese Ausgabe zeigt, dass unsere Blasensortierungsimplementierung das Array korrekt in aufsteigender Reihenfolge sortiert hat.
Um das Programm auszuführen, müssen wir es mit einem C-Compiler kompilieren. Hier ist ein Beispiel Kompilierungsbefehl für GCC:
wie viele Wochen pro Monat
gcc -o bubble_sort bubble_sort.c
Dieser Befehl kompiliert die Datei bubble_sort.c und erstellt eine ausführbare Datei mit dem Namen bubble_sort.
Zusammenfassend lässt sich sagen, dass der Blasensortierungsalgorithmus wiederholt benachbarte Elemente vertauscht, bis das Array sortiert ist. Der Algorithmus hat eine Zeitkomplexität von O(n2), was es für große Datenmengen ineffizient macht. Es ist jedoch für Bildungszwecke und kleine Datensätze nützlich. Wir haben den Bubble-Sort-Algorithmus in der Programmiersprache C implementiert und anhand eines einfachen Beispiels getestet.
Eigenschaften:
- Bubble Sort ist ein einfacher Sortieralgorithmus.
- Es funktioniert, indem benachbarte Elemente wiederholt ausgetauscht werden, wenn sie in der falschen Reihenfolge sind.
- Der Algorithmus sortiert das Array in aufsteigender oder absteigender Reihenfolge.
- Es hat eine Zeitkomplexität von O(n2) im schlimmsten Fall, wobei n die Größe des Arrays ist.
Verwendung:
- Die Blasensortierung ist für Bildungszwecke und kleine Datensätze nützlich.
- Aufgrund seiner zeitlichen Komplexität ist es nicht für große Datenmengen geeignet.
Vorteile:
- Die Blasensortierung ist leicht zu verstehen und umzusetzen.
- Für die Sortierung ist nur minimaler zusätzlicher Speicherplatz erforderlich.
Nachteile:
- Aufgrund der zeitlichen Komplexität ist es für große Datenmengen nicht effizient.
- Im Vergleich zu anderen Sortieralgorithmen wie Quicksort und Mergesort ist die Leistung schlecht.
Abschluss:
Bubble Sort ist ein einfacher und intuitiver Sortieralgorithmus, der für Bildungszwecke und kleine Datensätze nützlich ist. Aufgrund seiner zeitlichen Komplexität ist es jedoch für große Datenmengen ineffizient. Daher wird es in realen Anwendungen nicht häufig verwendet. Andere Sortieralgorithmen wie Quicksort und Mergesort sind für große Datenmengen effizienter.