Il consiste à faire remonter le plus grand élément du tableau (comme une bulle d'air remonte à la surface) en comparant les éléments successifs. C'est-à-dire qu'on va comparer le 1er et le 2e élément du tableau, conserver le plus grand et puis les échanger s'ils sont désordonnés les uns par rapport aux autres. On recommence cette opération jusqu'à la fin du tableau. Ensuite, il ne reste plus qu'à renouveler cela jusqu'à l'avant-dernière place et ainsi de suite… On arrête quand le tableau à trier est de taille 1 ou qu'on n'a pas fait d'échanges au dernier passage.

En Pascal

const MAX = 100; (* MAX = 100 est donné en exemple seulement *)

type tab = array [1..MAX] of integer;
procedure TriBulle(n : integer ; var t : tab);
var i, j, tmp : integer;
begin

        (* On va trier les n-1 premiers éléments du tableau *)
        for i:=1 to n-1 do begin
                j := i;
                (* L'éléments d'indice i doit reculer *)

                (* Jusqu'à prendre sa place           *)
                while (j >= 1) and (t[j+1] < t[j]) do begin

                        tmp := t[j];
                        t[j] := t[j+1];
                        t[j+1] := tmp;
                        j := j - 1;
                end;
        end;
end;

En C

#define TRUE 1

#define FALSE 0
typedef int tab_entiers[MAX];
 
void tri_a_bulle(tab_entiers t) 
{
        int i   = 0; /* Indice de répétition du tri */
        int j   = 0; /* Variable de boucle */

        int tmp = 0; /* Variable de stockage temporaire */
 
        /* Booléen marquant l'arrêt du tri si le tableau est ordonné */
        int en_desordre = TRUE; 
 
        /* Boucle de répétition du tri et le test qui
           arrête le tri dès que le tableau est ordonné */

        for(i = 0 ; (i < MAX) && en_desordre; i++)
        {  
                /* Supposons le tableau ordonné */
                en_desordre = FALSE;
 
                /* Vérification des éléments des places j et j-1 */

                for(j = 1 ; j < MAX - i ; j++) 
                {
                        /* Si les 2 éléments sont mal triés */
                        if(t[j] < t[j-1])

                        {
                                /* Inversion des 2 éléments */
                                tmp = t[j-1];
                                t[j-1] = t[j];
                                t[j] = tmp;
 
                                /* Le tableau n'est toujours pas trié */
                                en_desordre = TRUE;
                        }
                }

        }
} 

En Java

public static void triBulle(int tableau[])
       {
       int longueur=tableau.length;
       boolean permut;
       
       do

           {
           //hypothése : le tableau est trié
           permut=false;
           for(int i=0;i<longueur-1;i++)
               {
               //Teste si 2 éléments successifs sont dans le bon ordre ou non
               if(tableau[i]>tableau[i+1])
                   {
                   //s'ils ne le sont pas on échange leurs positions
                   echanger(tableau,i,i+1);
                   permut=true;
                   }
               }
            }
       while(permut);
       }