Tomuto článku alebo sekcii chýbajú odkazy na spoľahlivé zdroje, môže preto obsahovať informácie, ktoré je potrebné ešte overiť. Pomôžte Wikipédii a doplňte do článku citácie, odkazy na spoľahlivé zdroje.

Bublinkové triedenie (angl. bubble sort) je implementačne jednoduchý výmenný triediaci algoritmus. Pracuje na mieste a nepatrí medzi prirodzené triediace algoritmy. Pre praktické využitie je neefektívny.

Pracuje opakovaným prechodom cez zoznam, ktorý má byť utriedený porovnávajúc vždy dva prvky. Ak prvky nie sú v správnom poradí, zamení ich. Porovnávanie prvkov v zozname trvá, pokiaľ sú potrebné výmeny, teda pokiaľ nie je zoznam usporiadaný. Algoritmus dostal názov vďaka tomu, že menšie prvky sa „prebublinkujú“ na začiatok zoznamu.

Poznámka: toto je len jedna z variácií algoritmu.

Pre i od 1 po (počet prvkov)
  Pre j od 1 po (počet prvkov - i)
    Ak zoznam > zoznam
      Vymeň zoznam ↔ zoznam

for I := High(A) downto Low(A) do
   for J := Low(A) to High(A) - 1 do
     if A > A then
       begin
         T := A;
         A := A;
         A := T;
       end;

public static void bubbleSort(int array){
   for (int i = 0; i < array.length - 1; i++) {
       for (int j = 0; j < array.length - i - 1; j++) {
           if(array < array){
               int tmp = array;
               array = array;
               array = tmp;

           }
       }
   }
}

void bubbleSort(int * array, int size){
   for(int i = 0; i < size - 1; i++){
       for(int j = 0; j < size - i - 1; j++){
           if(array < array){
               int tmp = array;
               array = array;
               arrayj = tmp;
           }   
       }   
   }   
}    

static void BubbleSort(int arr)
{
   for (int i = 0; i < arr.Length - 1; i++)
   {
       for (int j = 0; j < arr.Length - i - 1; j++)
       {
           if (arrj + 1 < arrj)
           {
               int tmp = arrj + 1;
               arrj + 1 = arrj;
               arrj = tmp;
           }
       }
   }
}

function bubbleSort(array){
   for (var i = 0; i < array.length - 1; i++) {
       for (var j = 0; j < array.length - i - 1; j++) {
           if(arrayj < arrayj+1){
               var tmp = arrayj;
               arrayj = arrayj+1;
               arrayj+1 = tmp;
           }
       }
   }
}   

procedure BubbleSort(var X : ArrayType; N : integer);
var
 I,
 J : integer;
begin
 for I := 2 to N do
   begin
     for J := N downto I do
       if (XJ > XJ - 1) then
         Swap(XJ - 1, XJ);
   end
end;

procedure Swap(var X, Y : integer);
var
 Temp : integer;
begin
 Temp := X;
 X := Y;
 Y := Temp
end;

function bubble_sort($arr)
{
   $count = count($arr);
   for($i = 0; $i < $count - 1; $i++) {
       for($j = 0; $j < $count - $i - 1; $j++) {
           if($arr$j + 1 < $arr$j) {
               $tmp = $arr$j + 1;
               $arr$j + 1 = $arr$j;
               $arr$j = $tmp;
           }
       }
   }
}

Asymptotická priemerná aj najhoršia zložitosť bublinkového triedenia je ${\displaystyle O(n^{2})}$.

Tento algoritmus triedenia je jedným z najhorších, oproti iným algoritmom s rovnakou rádovou zložitosťou vyžaduje veľa zápisov do pamäte a neefektívnu prácu s cache procesora. Takmer neexistuje prípad, kedy by mal nejakú výhodu oproti iným postupom.