Boble sortering er en enkel og intuitiv sorteringsalgoritme. Det udskifter gentagne gange tilstødende elementer, hvis de er i den forkerte rækkefølge, indtil arrayet er sorteret. I denne algoritme 'bobler' det største element op til slutningen af arrayet i hver iteration. Boblesortering er ineffektivt til store datasæt, men det er nyttigt til undervisningsformål og små datasæt. I denne artikel vil vi implementere boblesorteringsalgoritmen i programmeringssproget C.
Det første trin er at definere boblesorteringsfunktionen. Denne funktion tager et heltalsarray og størrelsen af arrayet som dets parametre. Funktionen returnerer intet, da den ændrer det oprindelige array. Her er funktionsdefinition:
hvordan man konverterer int til streng java
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> Funktionen har to sløjfer. Den ydre sløjfe løber fra det første element til det næstsidste element i arrayet. Den indre løkke løber fra det første element til det næstsidste element i den usorterede del af arrayet. Betingelsen for den indre sløjfe er n - i - 1, fordi de sidste i elementer i arrayet allerede er sorteret.
I hver iteration af den indre løkke sammenligner vi tilstødende elementer. Hvis det venstre element er større end det højre element, bytter vi dem. Når den indre løkke er fuldført, er det største element garanteret for enden af den usorterede del af arrayet.
Nu kan vi skrive hovedfunktionen for at teste vores boblesorteringsimplementering. Her er hovedfunktionen sammen med den forrige del:
C-program:
#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> Dette output viser, at vores boblesorteringsimplementering sorterede arrayet korrekt i stigende rækkefølge.
For at køre programmet skal vi kompilere det ved hjælp af en C-kompiler. Her er et eksempel kompileringskommando for GCC:
gcc -o bubble_sort bubble_sort.c
Denne kommando kompilerer filen bubble_sort.c og producerer en eksekverbar fil med navnet bubble_sort.
Sammenfattende skifter boblesorteringsalgoritmen gentagne gange tilstødende elementer, indtil arrayet er sorteret. Algoritmen har en tidskompleksitet på O(n2), hvilket gør det ineffektivt for store datasæt. Det er dog nyttigt til undervisningsformål og små datasæt. Vi implementerede boblesorteringsalgoritmen i programmeringssproget C og testede den ved hjælp af et simpelt eksempel.
ssis
Egenskaber:
- Boblesortering er en simpel sorteringsalgoritme.
- Det fungerer ved gentagne gange at bytte tilstødende elementer, hvis de er i den forkerte rækkefølge.
- Algoritmen sorterer arrayet i stigende eller faldende rækkefølge.
- Den har en tidskompleksitet på O(n2) i værste fald, hvor n er størrelsen af arrayet.
Anvendelse:
- Boblesortering er nyttig til undervisningsformål og små datasæt.
- Det er ikke egnet til store datasæt på grund af dets tidskompleksitet.
Fordele:
- Boblesortering er let at forstå og implementere.
- Det kræver minimal ekstra hukommelsesplads at udføre sorteringen.
Ulemper:
- Det er ikke effektivt til store datasæt på grund af dets tidskompleksitet.
- Den har dårlig ydeevne sammenlignet med andre sorteringsalgoritmer, såsom quicksort og mergesort.
Konklusion:
Boblesortering er en enkel og intuitiv sorteringsalgoritme, der er nyttig til undervisningsformål og små datasæt. Dens tidskompleksitet gør den imidlertid ineffektiv for store datasæt. Derfor er det ikke almindeligt brugt i virkelige applikationer. Andre sorteringsalgoritmer, såsom quicksort og mergesort, er mere effektive til store datasæt.