TechCodeview

Burbuļu šķirošana ir vienkāršs un intuitīvs šķirošanas algoritms. Tas atkārtoti apmaina blakus esošos elementus, ja tie atrodas nepareizā secībā, līdz masīvs tiek sakārtots. Šajā algoritmā lielākais elements “burbuļo” līdz masīva beigām katrā iterācijā. Burbuļu kārtošana ir neefektīva lielām datu kopām, taču tā ir noderīga izglītojošiem nolūkiem un mazām datu kopām. Šajā rakstā mēs ieviesīsim burbuļu kārtošanas algoritmu C programmēšanas valodā.

Pirmais solis ir definēt burbuļu kārtošanas funkciju. Šī funkcija kā parametrus izmanto veselu skaitļu masīvu un masīva lielumu. Funkcija neatgriež neko, jo tā maina sākotnējo masīvu. Šeit ir funkcijas definīcija:

 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>

Funkcijai ir divas cilpas. Ārējā cilpa sākas no pirmā elementa līdz otrajam pēdējam masīva elementam. Iekšējā cilpa iet no pirmā elementa līdz otrajam pēdējam masīva nešķirotās daļas elementam. Iekšējās cilpas nosacījums ir n - i - 1, jo pēdējie i masīva elementi jau ir sakārtoti.

Katrā iekšējās cilpas iterācijā mēs salīdzinām blakus esošos elementus. Ja kreisais elements ir lielāks par labo, mēs tos apmainām. Pēc iekšējās cilpas pabeigšanas lielākais elements garantēti atrodas masīva nešķirotās daļas beigās.

Tagad mēs varam uzrakstīt galveno funkciju, lai pārbaudītu mūsu burbuļu kārtošanas ieviešanu. Šeit ir galvenā funkcija kopā ar iepriekšējo daļu:

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(&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>

Šī izvade parāda, ka mūsu burbuļu kārtošanas ieviešana pareizi sakārtoja masīvu augošā secībā.

Lai palaistu programmu, mums tā ir jākompilē, izmantojot C kompilatoru. Šeit ir piemērs kompilācijas komanda GCC:

 gcc -o bubble_sort bubble_sort.c 

Šī komanda apkopo failu bubble_sort.c un izveido izpildāmu failu ar nosaukumu bubble_sort.

Rezumējot, burbuļu kārtošanas algoritms atkārtoti apmaina blakus esošos elementus, līdz masīvs ir sakārtots. Algoritma laika sarežģītība ir O(n²), kas padara to neefektīvu lielām datu kopām. Tomēr tas ir noderīgi izglītības nolūkos un nelielām datu kopām. Mēs ieviesām burbuļu kārtošanas algoritmu C programmēšanas valodā un pārbaudījām, izmantojot vienkāršu piemēru.

Raksturlielumi:

• Burbuļu kārtošana ir vienkāršs šķirošanas algoritms.
• Tas darbojas, atkārtoti apmainot blakus esošos elementus, ja tie atrodas nepareizā secībā.
• Algoritms sakārto masīvu augošā vai dilstošā secībā.
• Tā laika sarežģītība ir O (n²) sliktākajā gadījumā, kur n ir masīva lielums.

Lietošana:

• Burbuļu kārtošana ir noderīga izglītības nolūkos un nelielām datu kopām.
• Tas nav piemērots lielām datu kopām tās laika sarežģītības dēļ.

Priekšrocības:

• Burbuļu kārtošana ir viegli saprotama un īstenojama.
• Lai veiktu šķirošanu, ir nepieciešama minimāla papildu atmiņas vieta.

Trūkumi:

• Tas nav efektīvs lielām datu kopām laika sarežģītības dēļ.
• Tam ir vāja veiktspēja salīdzinājumā ar citiem šķirošanas algoritmiem, piemēram, ātro kārtošanu un sapludināšanu.

Secinājums:

Burbuļu kārtošana ir vienkāršs un intuitīvs kārtošanas algoritms, kas noder izglītojošiem nolūkiem un nelielām datu kopām. Tomēr tā laika sarežģītība padara to neefektīvu lielām datu kopām. Tāpēc to parasti neizmanto reālās pasaules lietojumprogrammās. Citi šķirošanas algoritmi, piemēram, ātrā kārtošana un sapludināšana, ir efektīvāki lielām datu kopām.