TechCodeview

Boble sortering er en enkel og intuitiv sorteringsalgoritme. Den bytter gjentatte ganger tilstøtende elementer hvis de er i feil rekkefølge til matrisen er sortert. I denne algoritmen 'bobler' det største elementet opp til slutten av matrisen i hver iterasjon. Boblesortering er ineffektivt for store datasett, men det er nyttig for pedagogiske formål og små datasett. I denne artikkelen vil vi implementere boblesorteringsalgoritmen i programmeringsspråket C.

Det første trinnet er å definere boblesorteringsfunksjonen. Denne funksjonen tar en heltallsmatrise og størrelsen på matrisen som parametere. Funksjonen returnerer ingenting ettersom den endrer den opprinnelige matrisen. Her er funksjonsdefinisjon:

typekonvertering og casting i 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>

Funksjonen har to løkker. Den ytre sløyfen går fra det første elementet til det nest siste elementet i arrayet. Den indre sløyfen går fra det første elementet til det nest siste elementet i den usorterte delen av matrisen. Tilstanden til den indre sløyfen er n - i - 1 fordi de siste i-elementene i matrisen allerede er sortert.

I hver iterasjon av den indre løkken sammenligner vi tilstøtende elementer. Hvis det venstre elementet er større enn det høyre elementet, bytter vi dem. Etter at den indre sløyfen er fullført, er garantert det største elementet i enden av den usorterte delen av arrayet.

Nå kan vi skrive hovedfunksjonen for å teste vår boblesorteringsimplementering. Her er hovedfunksjonen sammen med 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(&apos;Sorted array: &apos;); 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>

Denne utgangen viser at vår boblesorteringsimplementering sorterte matrisen riktig i stigende rekkefølge.

For å kjøre programmet må vi kompilere det ved hjelp av en C-kompilator. Her er et eksempel kompileringskommando for GCC:

 gcc -o bubble_sort bubble_sort.c 

Denne kommandoen kompilerer filen bubble_sort.c og produserer en kjørbar fil kalt bubble_sort.

Oppsummert bytter boblesorteringsalgoritmen gjentatte ganger tilstøtende elementer til matrisen er sortert. Algoritmen har en tidskompleksitet på O(n²), som gjør den ineffektiv for store datasett. Det er imidlertid nyttig for pedagogiske formål og små datasett. Vi implementerte boblesorteringsalgoritmen i programmeringsspråket C og testet den ved å bruke et enkelt eksempel.

ssis

Kjennetegn:

• Boblesortering er en enkel sorteringsalgoritme.
• Det fungerer ved å gjentatte ganger bytte tilstøtende elementer hvis de er i feil rekkefølge.
• Algoritmen sorterer matrisen i stigende eller synkende rekkefølge.
• Den har en tidskompleksitet på O(n²) i verste fall, hvor n er størrelsen på matrisen.

Bruk:

• Boblesortering er nyttig for pedagogiske formål og små datasett.
• Den er ikke egnet for store datasett på grunn av tidskompleksiteten.

Fordeler:

• Boblesortering er lett å forstå og implementere.
• Det krever minimalt med ekstra minneplass for å utføre sorteringen.

Ulemper:

• Det er ikke effektivt for store datasett på grunn av tidskompleksiteten.
• Den har dårlig ytelse sammenlignet med andre sorteringsalgoritmer, som quicksort og mergesort.

Konklusjon:

Boblesortering er en enkel og intuitiv sorteringsalgoritme som er nyttig for pedagogiske formål og små datasett. Tidskompleksiteten gjør den imidlertid ineffektiv for store datasett. Derfor er det ikke ofte brukt i virkelige applikasjoner. Andre sorteringsalgoritmer, som quicksort og mergesort, er mer effektive for store datasett.