Bellensoort is een eenvoudig en intuïtief sorteeralgoritme. Het verwisselt herhaaldelijk aangrenzende elementen als ze in de verkeerde volgorde staan totdat de array is gesorteerd. In dit algoritme 'borrelt' het grootste element in elke iteratie naar het einde van de array. Het sorteren van bellen is inefficiënt voor grote datasets, maar is nuttig voor educatieve doeleinden en kleine datasets. In dit artikel zullen we het bubble sort-algoritme implementeren in de programmeertaal C.
De eerste stap is het definiëren van de belsorteerfunctie. Deze functie gebruikt een array met gehele getallen en de grootte van de array als parameters. De functie retourneert niets omdat deze de oorspronkelijke array wijzigt. Hier is de functiedefinitie:
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> De functie heeft twee lussen. De buitenste lus loopt van het eerste element tot het op een na laatste element van de array. De binnenste lus loopt van het eerste element tot het op een na laatste element van het ongesorteerde deel van de array. De voorwaarde van de binnenste lus is n - i - 1 omdat de laatste i elementen van de array al zijn gesorteerd.
In elke iteratie van de binnenste lus vergelijken we aangrenzende elementen. Als het linkerelement groter is dan het rechterelement, wisselen we ze om. Nadat de binnenste lus is voltooid, bevindt het grootste element zich gegarandeerd aan het einde van het ongesorteerde deel van de array.
Nu kunnen we de hoofdfunctie schrijven om onze implementatie van bellensortering te testen. Hier is de hoofdfunctie samen met het vorige deel:
C-programma:
#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> Uit deze uitvoer blijkt dat onze implementatie van bellensortering de array correct in oplopende volgorde heeft gesorteerd.
Om het programma uit te voeren, moeten we het compileren met een C-compiler. Hier is een voorbeeld compilatiecommando voor GCC:
gcc -o bubble_sort bubble_sort.c
Met deze opdracht wordt het bestand bubble_sort.c gecompileerd en wordt een uitvoerbaar bestand met de naam bubble_sort geproduceerd.
Samenvattend: het bellensorteeralgoritme verwisselt herhaaldelijk aangrenzende elementen totdat de array is gesorteerd. Het algoritme heeft een tijdscomplexiteit van O(n2), wat het inefficiënt maakt voor grote datasets. Het is echter nuttig voor educatieve doeleinden en kleine datasets. We hebben het bubble sort-algoritme in de programmeertaal C geïmplementeerd en getest aan de hand van een eenvoudig voorbeeld.
Kenmerken:
- Bubble sort is een eenvoudig sorteeralgoritme.
- Het werkt door aangrenzende elementen herhaaldelijk te verwisselen als ze in de verkeerde volgorde staan.
- Het algoritme sorteert de array in oplopende of aflopende volgorde.
- Het heeft een tijdscomplexiteit van O(n2) in het ergste geval, waarbij n de grootte van de array is.
Gebruik:
- Bellen sorteren is handig voor educatieve doeleinden en kleine datasets.
- Het is niet geschikt voor grote datasets vanwege de tijdscomplexiteit.
Voordelen:
- Bellen sorteren is gemakkelijk te begrijpen en te implementeren.
- Er is minimale extra geheugenruimte nodig om de sortering uit te voeren.
Nadelen:
- Het is niet efficiënt voor grote datasets vanwege de tijdscomplexiteit.
- Het presteert slecht in vergelijking met andere sorteeralgoritmen, zoals quicksort en mergesort.
Conclusie:
Bubble sort is een eenvoudig en intuïtief sorteeralgoritme dat handig is voor educatieve doeleinden en kleine datasets. De tijdscomplexiteit maakt het echter inefficiënt voor grote datasets. Daarom wordt het niet vaak gebruikt in toepassingen in de echte wereld. Andere sorteeralgoritmen, zoals quicksort en mergesort, zijn efficiënter voor grote datasets.