Kuplalajittelu on yksinkertainen ja intuitiivinen lajittelualgoritmi. Se vaihtaa toistuvasti vierekkäisiä elementtejä, jos ne ovat väärässä järjestyksessä, kunnes taulukko on lajiteltu. Tässä algoritmissa suurin elementti 'kuplii' taulukon loppuun jokaisessa iteraatiossa. Kuplalajittelu on tehoton suurille tietojoukoille, mutta se on hyödyllinen koulutustarkoituksiin ja pienille tietojoukoille. Tässä artikkelissa toteutamme kuplalajittelualgoritmin C-ohjelmointikielellä.
Ensimmäinen vaihe on määrittää kuplalajittelutoiminto. Tämä funktio ottaa parametreiksi kokonaislukutaulukon ja taulukon koon. Funktio ei palauta mitään, koska se muuttaa alkuperäistä taulukkoa. Tässä on funktion määritelmä:
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> Toiminnossa on kaksi silmukkaa. Ulompi silmukka kulkee taulukon ensimmäisestä elementistä toiseksi viimeiseen elementtiin. Sisäsilmukka kulkee taulukon lajittelemattoman osan ensimmäisestä elementistä toiseksi viimeiseen elementtiin. Sisäsilmukan ehto on n - i - 1, koska taulukon viimeiset i-elementit on jo lajiteltu.
Jokaisessa sisäisen silmukan iteraatiossa vertaamme vierekkäisiä elementtejä. Jos vasen elementti on suurempi kuin oikea elementti, vaihdamme ne. Kun sisempi silmukka on valmis, suurin elementti on taatusti taulukon lajittelemattoman osan lopussa.
Nyt voimme kirjoittaa päätoiminnon testataksemme kuplalajittelun toteutusta. Tässä on päätoiminto edellisen osan kanssa:
C-ohjelma:
#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> Tämä tulos osoittaa, että kuplalajittelutoteutusmme lajitteli taulukon oikein nousevaan järjestykseen.
Ohjelman suorittamiseksi meidän on käännettävä se C-kääntäjällä. Tässä on esimerkki käännöskomento GCC:lle:
gcc -o bubble_sort bubble_sort.c
Tämä komento kokoaa bubble_sort.c-tiedoston ja tuottaa suoritettavan tiedoston nimeltä bubble_sort.
Yhteenvetona voidaan todeta, että kuplalajittelualgoritmi vaihtaa toistuvasti vierekkäisiä elementtejä, kunnes taulukko on lajiteltu. Algoritmin aikakompleksisuus on O(n2), mikä tekee siitä tehottoman suurille tietojoukoille. Se on kuitenkin hyödyllinen koulutustarkoituksiin ja pieniin tietokokonaisuuksiin. Totesimme kuplalajittelualgoritmin C-ohjelmointikielellä ja testasimme sitä yksinkertaisella esimerkillä.
Ominaisuudet:
- Kuplalajittelu on yksinkertainen lajittelualgoritmi.
- Se toimii vaihtamalla toistuvasti vierekkäisiä elementtejä, jos ne ovat väärässä järjestyksessä.
- Algoritmi lajittelee taulukon nousevaan tai laskevaan järjestykseen.
- Sen aikamonimutkaisuus on O(n2) pahimmassa tapauksessa, jossa n on taulukon koko.
Käyttö:
- Bubble lajittelu on hyödyllinen koulutustarkoituksiin ja pieniin tietokokonaisuuksiin.
- Se ei sovellu suurille tietojoukoille ajallisen monimutkaisuutensa vuoksi.
Edut:
- Bubble lajittelu on helppo ymmärtää ja toteuttaa.
- Lajittelu vaatii vain vähän lisämuistia.
Haitat:
- Se ei ole tehokas suurille tietojoukoille sen aikamonimutkaisuuden vuoksi.
- Sen suorituskyky on huono verrattuna muihin lajittelualgoritmeihin, kuten pikalajitteluun ja yhdistämiseen.
Johtopäätös:
Bubble sort on yksinkertainen ja intuitiivinen lajittelualgoritmi, joka on hyödyllinen opetustarkoituksiin ja pieniin tietokokonaisuuksiin. Ajan monimutkaisuus tekee siitä kuitenkin tehottoman suurille tietojoukoille. Siksi sitä ei yleisesti käytetä reaalimaailman sovelluksissa. Muut lajittelualgoritmit, kuten pikalajittelu ja yhdistäminen, ovat tehokkaampia suurille tietojoukoille.