Bublinové triedenie je jednoduchý a intuitívny triediaci algoritmus. Opakovane zamieňa susedné prvky, ak sú v nesprávnom poradí, kým sa pole neroztriedi. V tomto algoritme najväčší prvok „prebubláva“ na koniec poľa v každej iterácii. Bublinové triedenie je neefektívne pre veľké súbory údajov, ale je užitočné na vzdelávacie účely a malé súbory údajov. V tomto článku implementujeme algoritmus triedenia bublín v programovacom jazyku C.
Prvým krokom je definovanie funkcie bublinového triedenia. Táto funkcia berie ako parametre celočíselné pole a veľkosť poľa. Funkcia nevracia nič, pretože upravuje pôvodné pole. Tu je definícia funkcie:
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> Funkcia má dve slučky. Vonkajšia slučka prebieha od prvého prvku po predposledný prvok poľa. Vnútorná slučka prebieha od prvého prvku po predposledný prvok netriedenej časti poľa. Podmienka vnútornej slučky je n - i - 1, pretože posledné i prvky poľa sú už zoradené.
V každej iterácii vnútornej slučky porovnávame susedné prvky. Ak je ľavý prvok väčší ako pravý prvok, vymeníme ich. Po dokončení vnútornej slučky je zaručené, že najväčší prvok bude na konci nezoradenej časti poľa.
Teraz môžeme napísať hlavnú funkciu na testovanie našej implementácie triedenia bublín. Tu je hlavná funkcia spolu s predchádzajúcou časťou:
Program C:
algoritmus minimax
#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> Tento výstup ukazuje, že naša implementácia bublinového triedenia správne zoradila pole vo vzostupnom poradí.
Aby sme program spustili, musíme ho skompilovať pomocou kompilátora C. Tu je príklad kompilačný príkaz pre GCC:
gcc -o bubble_sort bubble_sort.c
Tento príkaz skompiluje súbor bubble_sort.c a vytvorí spustiteľný súbor s názvom bubble_sort.
Stručne povedané, algoritmus bublinového triedenia opakovane zamieňa susedné prvky, kým sa pole neroztriedi. Algoritmus má časovú zložitosť O(n2), čo ho robí neefektívnym pre veľké súbory údajov. Je však užitočný na vzdelávacie účely a malé súbory údajov. Algoritmus triedenia bublín sme implementovali v programovacom jazyku C a otestovali sme ho na jednoduchom príklade.
Charakteristika:
- Bublinové triedenie je jednoduchý triediaci algoritmus.
- Funguje to tak, že sa priľahlé prvky opakovane vymieňajú, ak sú v nesprávnom poradí.
- Algoritmus triedi pole vo vzostupnom alebo zostupnom poradí.
- Má časovú zložitosť O(n2) v najhoršom prípade, kde n je veľkosť poľa.
Použitie:
- Bublinové triedenie je užitočné na vzdelávacie účely a malé súbory údajov.
- Pre svoju časovú náročnosť nie je vhodný pre veľké súbory údajov.
Výhody:
- Bublinové triedenie je jednoduché na pochopenie a implementáciu.
- Na vykonanie triedenia je potrebný minimálny dodatočný priestor v pamäti.
Nevýhody:
- Nie je efektívny pre veľké súbory údajov z dôvodu jeho časovej zložitosti.
- Má slabý výkon v porovnaní s inými triediacimi algoritmami, ako sú quicksort a mergesort.
Záver:
Bublinové triedenie je jednoduchý a intuitívny triediaci algoritmus, ktorý je užitočný na vzdelávacie účely a malé súbory údajov. Jeho časová zložitosť ho však robí neefektívnym pre veľké súbory údajov. Preto sa bežne nepoužíva v reálnych aplikáciách. Iné triediace algoritmy, ako napríklad quicksort a mergesort, sú efektívnejšie pre veľké súbory údajov.