Uygulanması en basit olan sıralama algoritmasıdır.

Dizilerin elemanlarını birbiriyle karşılaştırıp büyüklüğüne göre yer değiştirme yapar.

Bir örnek üzerinde inceleyecek olursak:
Örneğimizde küçükten büyüğe sıralama yapacağız.

1. Adım:
8 0 3 5 2 4  —  0 8 3 5 2 4
0 8 3 5 2 4  —  0 3 8 5 2 4
0 3 8 5 2 4  —  0 3 5 8 2 4
0 3 5 8 2 4  —  0 3 5 2 8 4
0 3 5 2 8 4  —  0 3 5 2 4 8 (8 elemanının en büyük olduğunu bulduk ve dizinin son elemanı olarak atadık. Bundan sonra bu elemanı kontrol etmeyeceğiz)

2. Adım:
0 3 5 2 4 8  —  0 3 5 2 4 8
0 3 5 2 4 8  —  0 3 5 2 4 8
0 3 5 2 4 8  —  0 3 2 5 4 8
0 3 2 4 5 8  —  0 3 2 4 5 8 (5 elemanının kendinden önceki elemanlardan büyük olduğunu bulduk ve sondan 2. sıraya yerleştirdik)

3. Adım:
0 3 2 4 5 8  —  0 3 2 4 5 8
0 3 2 4 5 8  —  0 2 3 4 5 8
0 2 3 4 5 8  —  0 2 3 4 5 8 (4 elemanının kendinden önceki elemanlardan büyük olduğunu bulduk ve sondan 3. sıraya yerleştirdik)

4. Adım:
0 2 3 4 5 8  —  0 2 3 4 5 8
0 2 3 4 5 8  —  0 2 3 4 5 8 (3 elemanının kendinden önceki elemanlardan büyük olduğunu bulduk ve sondan 4. sıraya yerleştirdik)

5. Adım:
0 2 3 4 5 8  —  0 2 3 4 5 8 (2 elemanının kendinden önceki elemanlardan büyük olduğunu bulduk ve sondan 5. sıraya yerleştirdik)

C# kodu aşağıdaki gibidir:

 

        public void BubbleSort(int[] dizi)
        {
            int gecici;
            for (int i = 0; i <= dizi.Length – 1; i++)
            {
                for (int j = 1; j <= dizi.Length – 1; j++)
                {
                    if (dizi[j – 1] > dizi[j])
                    {
                        gecici = dizi[j – 1];
                        dizi[j – 1] = dizi[j];
                        dizi[j] = gecici;
                    }
                }
            }
        }
 veya

        public void BubbleSort2(int[] dizi)
        {
            int[] dizi = { 8, 0, 3, 5, 2, 4 };
            int gecici;
            for (int i = dizi.Length – 1; i >= 0; i–)
            {
                for (int j = 1; j <= dizi.Length – 1; j++)
                {
                    if (dizi[j – 1] > dizi[j])
                    {
                        gecici = dizi[j – 1];
                        dizi[j – 1] = dizi[j];
                        dizi[j] = gecici;
                    }
                }
            }
        }