Razvrščanje mehurčkov je preprost in intuitiven algoritem za razvrščanje. Večkrat zamenja sosednje elemente, če so v napačnem vrstnem redu, dokler matrika ni razvrščena. V tem algoritmu se največji element v vsaki ponovitvi 'povzpne' na konec niza. Razvrščanje z mehurčki je neučinkovito za velike nabore podatkov, je pa uporabno za izobraževalne namene in majhne nabore podatkov. V tem članku bomo implementirali algoritem mehurčkov za razvrščanje v programskem jeziku C.
Prvi korak je definiranje funkcije mehurčkov. Ta funkcija kot parametra vzame matriko celih števil in velikost matrike. Funkcija ne vrne ničesar, saj spremeni izvirno matriko. Tukaj je definicija funkcije:
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> Funkcija ima dve zanki. Zunanja zanka teče od prvega elementa do predzadnjega elementa matrike. Notranja zanka teče od prvega elementa do predzadnjega elementa nerazvrščenega dela matrike. Pogoj notranje zanke je n - i - 1, ker je zadnjih i elementov matrike že razvrščenih.
V vsaki ponovitvi notranje zanke primerjamo sosednje elemente. Če je levi element večji od desnega, ju zamenjamo. Ko se notranja zanka konča, je največji element zagotovljeno na koncu nerazvrščenega dela matrike.
Zdaj lahko napišemo glavno funkcijo za preizkus naše izvedbe razvrščanja z mehurčki. Tukaj je glavna funkcija skupaj s prejšnjim delom:
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> Ta rezultat kaže, da je naša izvedba razvrščanja z mehurčki pravilno razvrstila matriko v naraščajočem vrstnem redu.
Za zagon programa ga moramo prevesti s prevajalnikom C. Tukaj je primer ukaz za prevajanje za GCC:
gcc -o bubble_sort bubble_sort.c
Ta ukaz prevede datoteko bubble_sort.c in ustvari izvršljivo datoteko z imenom bubble_sort.
Če povzamemo, algoritem mehurčkastega razvrščanja vedno znova zamenja sosednje elemente, dokler ni matrika razvrščena. Algoritem ima časovno kompleksnost O(n2), zaradi česar je neučinkovit za velike nize podatkov. Vendar pa je uporaben za izobraževalne namene in majhne nize podatkov. Algoritem bubble sort smo implementirali v programskem jeziku C in ga preizkusili na preprostem primeru.
Značilnosti:
- Bubble sort je preprost algoritem za razvrščanje.
- Deluje tako, da večkrat zamenja sosednje elemente, če so v napačnem vrstnem redu.
- Algoritem razvrsti matriko v naraščajočem ali padajočem vrstnem redu.
- Ima časovno kompleksnost O(n2) v najslabšem primeru, kjer je n velikost polja.
Uporaba:
- Razvrščanje z mehurčki je uporabno za izobraževalne namene in majhne nize podatkov.
- Zaradi časovne zapletenosti ni primeren za velike nize podatkov.
Prednosti:
- Razvrščanje z mehurčki je preprosto razumljivo in implementirano.
- Za razvrščanje potrebuje minimalen dodatni pomnilniški prostor.
Slabosti:
- Zaradi časovne zapletenosti ni učinkovit za velike nize podatkov.
- Ima slabo zmogljivost v primerjavi z drugimi algoritmi za razvrščanje, kot sta hitro razvrščanje in združevanje.
Zaključek:
Bubble sort je preprost in intuitiven algoritem za razvrščanje, ki je uporaben za izobraževalne namene in majhne nize podatkov. Vendar pa je zaradi časovne zapletenosti neučinkovit za velike nize podatkov. Zato se v aplikacijah v realnem svetu pogosto ne uporablja. Drugi algoritmi za razvrščanje, kot sta hitro razvrščanje in združevanje, so učinkovitejši za velike nize podatkov.