Kabarcık sıralaması basit ve sezgisel bir sıralama algoritmasıdır. Dizi sıralanana kadar bitişik öğelerin yanlış sırada olması durumunda tekrar tekrar yer değiştirir. Bu algoritmada, her yinelemede en büyük öğe dizinin sonuna kadar 'kabarcıklar' oluşturur. Kabarcık sıralaması büyük veri kümeleri için verimsizdir ancak eğitim amaçlı ve küçük veri kümeleri için kullanışlıdır. Bu yazımızda bubble sort algoritmasını C programlama dilinde uygulayacağız.
İlk adım kabarcık sıralama fonksiyonunu tanımlamaktır. Bu işlev, bir tamsayı dizisini ve dizinin boyutunu parametre olarak alır. İşlev, orijinal diziyi değiştirdiği için hiçbir şey döndürmez. İşte fonksiyon tanımı:
sql'de substring_index
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> Fonksiyonun iki döngüsü vardır. Dış döngü, dizinin ilk elemanından sondan ikinci elemanına kadar uzanır. İç döngü, dizinin sıralanmamış kısmının ilk elemanından ikinci-son elemanına kadar uzanır. İç döngünün koşulu n - i - 1'dir çünkü dizinin son i öğeleri zaten sıralanmıştır.
İç döngünün her yinelemesinde bitişik elemanları karşılaştırırız. Soldaki eleman sağdaki elemandan büyükse onları değiştiririz. İç döngü tamamlandıktan sonra en büyük elemanın dizinin sıralanmamış kısmının sonunda olması garanti edilir.
Artık bubble sort uygulamamızı test etmek için ana fonksiyonu yazabiliriz. Önceki bölümle birlikte ana işlevi burada bulabilirsiniz:
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> Bu çıktı, kabarcık sıralama uygulamamızın diziyi artan düzende doğru şekilde sıraladığını gösterir.
Programı çalıştırmak için C derleyicisi kullanarak derlememiz gerekir. İşte bir örnek GCC için derleme komutu:
gcc -o bubble_sort bubble_sort.c
Bu komut bubble_sort.c dosyasını derler ve bubble_sort adında yürütülebilir bir dosya oluşturur.
Özetle, kabarcık sıralama algoritması, dizi sıralanana kadar bitişik öğeleri tekrar tekrar değiştirir. Algoritmanın zaman karmaşıklığı O(n)'dir.2), bu da onu büyük veri kümeleri için verimsiz hale getirir. Ancak eğitim amaçlı ve küçük veri setleri için kullanışlıdır. Kabarcık sıralama algoritmasını C programlama dilinde uyguladık ve basit bir örnek kullanarak test ettik.
gri kod
Özellikler:
- Kabarcık sıralaması basit bir sıralama algoritmasıdır.
- Yanlış sırada olmaları durumunda bitişik elemanların tekrar tekrar değiştirilmesiyle çalışır.
- Algoritma diziyi artan veya azalan düzende sıralar.
- O(n) kadar zaman karmaşıklığına sahiptir.2) en kötü durumda, burada n dizinin boyutudur.
Kullanımı:
- Kabarcık sıralaması eğitim amaçlı ve küçük veri kümeleri için kullanışlıdır.
- Zaman karmaşıklığı nedeniyle büyük veri setleri için uygun değildir.
Avantajları:
- Kabarcık sıralamanın anlaşılması ve uygulanması kolaydır.
- Sıralamayı gerçekleştirmek için minimum ek bellek alanı gerekir.
Dezavantajları:
- Zaman karmaşıklığı nedeniyle büyük veri kümeleri için verimli değildir.
- Hızlı sıralama ve birleştirme sıralaması gibi diğer sıralama algoritmalarına kıyasla performansı düşüktür.
Çözüm:
Kabarcık sıralaması, eğitim amaçlı ve küçük veri kümeleri için yararlı olan basit ve sezgisel bir sıralama algoritmasıdır. Ancak zaman karmaşıklığı onu büyük veri kümeleri için verimsiz kılmaktadır. Bu nedenle gerçek dünya uygulamalarında yaygın olarak kullanılmaz. Hızlı sıralama ve birleştirme sıralaması gibi diğer sıralama algoritmaları büyük veri kümeleri için daha verimlidir.