Buborékos fajta egy egyszerű és intuitív rendezési algoritmus. Ismételten felcseréli a szomszédos elemeket, ha azok rossz sorrendben vannak, amíg a tömb meg nem rendeződik. Ebben az algoritmusban a legnagyobb elem minden iterációban a tömb végéig „buborékol fel”. A buborékos rendezés nem hatékony nagy adatkészletek esetén, de hasznos oktatási célokra és kis adatkészletek esetén. Ebben a cikkben a buborékrendezési algoritmust valósítjuk meg C programozási nyelven.
blokkolja a YouTube-hirdetéseket androidon
Az első lépés a buborékok rendezési funkciójának meghatározása. Ez a függvény egy egész tömböt és a tömb méretét veszi paraméterként. A függvény nem ad vissza semmit, mivel módosítja az eredeti tömböt. Itt van függvény meghatározása:
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> A függvénynek két ciklusa van. A külső ciklus a tömb első elemétől a második utolsó elemig fut. A belső ciklus a tömb rendezetlen részének első elemétől a második utolsó elemig fut. A belső ciklus feltétele n - i - 1, mert a tömb utolsó i elemei már rendezve vannak.
A belső ciklus minden iterációjában összehasonlítjuk a szomszédos elemeket. Ha a bal oldali elem nagyobb, mint a jobb oldali elem, akkor felcseréljük őket. A belső ciklus befejezése után a legnagyobb elem garantáltan a tömb rendezetlen részének végén lesz.
Most megírhatjuk a fő függvényt, hogy teszteljük a buborékrendezés megvalósítását. Itt van a fő funkció az előző résszel együtt:
öröklési program pythonban
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> Ez a kimenet azt mutatja, hogy a buborékos rendezés megvalósításunk megfelelően rendezte a tömböt növekvő sorrendben.
A program futtatásához le kell fordítanunk egy C fordító segítségével. Íme egy példa fordítási parancs a GCC-hez:
karakterlánc felosztása c++
gcc -o bubble_sort bubble_sort.c
Ez a parancs lefordítja a bubble_sort.c fájlt, és létrehoz egy bubble_sort nevű végrehajtható fájlt.
Összefoglalva, a buborékos rendezési algoritmus ismételten felcseréli a szomszédos elemeket, amíg a tömb meg nem rendeződik. Az algoritmus időbonyolultsága O(n2), ami nagy adathalmazok esetén nem hatékony. Azonban hasznos oktatási célokra és kis adathalmazokhoz. A buborékrendezési algoritmust C programozási nyelven implementáltuk, és egy egyszerű példán teszteltük.
Jellemzők:
- A buborékos rendezés egy egyszerű rendezési algoritmus.
- Úgy működik, hogy ismételten felcseréli a szomszédos elemeket, ha rossz sorrendben vannak.
- Az algoritmus növekvő vagy csökkenő sorrendbe rendezi a tömböt.
- Időbonyolultsága O(n2) a legrosszabb esetben, ahol n a tömb mérete.
Használat:
- A buborékos rendezés hasznos oktatási célokra és kis adatkészletekhez.
- Időbeli összetettsége miatt nem alkalmas nagy adathalmazokhoz.
Előnyök:
- A buborékos rendezés könnyen érthető és megvalósítható.
- A rendezés végrehajtásához minimális további memória szükséges.
Hátrányok:
- Időbeli összetettsége miatt nem hatékony nagy adathalmazokhoz.
- Gyenge teljesítményt nyújt más rendezési algoritmusokhoz képest, mint például a gyorsrendezés és az összevonás.
Következtetés:
A buborékos rendezés egy egyszerű és intuitív rendezési algoritmus, amely hasznos oktatási célokra és kis adatkészletekhez. Időbeli összetettsége azonban nagy adathalmazok esetén nem hatékony. Ezért a valós alkalmazásokban nem általánosan használják. Más rendezési algoritmusok, mint például a gyors rendezés és az összevonás, hatékonyabbak nagy adatkészletek esetén.