Sıralama Algoritmaları

(4, 1) (3, 7) (3, 1) (5, 6)

(3, 7) (3, 1) (4, 1) (5, 6) (sıra korunmuş)
(3, 1) (3, 7) (4, 1) (5, 6) (sıra değişmiş)

function gnomeSort(a[0..size-1]) {
i := 1
j := 2
while i < size - 1
if a[i-1] >= a
i := j
j := j + 1
else
swap a[i-1] and a
i := i - 1
if i = 0
i := 1
}

TEKRARLA
Ara index_sol için
sortFeld[index_sol] ≥ sortFeld[Pivot]
Ara index_sağ için
sortFeld[index_sağ] ≤ sortFeld[Pivot]
EĞER index_sol ve index_sağ bulundu ise
SONRA Değiştir
sortFeld[index_sol] ile sortFeld[index_sağ]
YOKSA
Bir element kaydır
SON EĞER
Koşul tamamlanıncaya kadar

urada ilk harf olan 'S' son harf olan 'L' ve orta harf olan 'B' karşılaştırılır.
İçlerinde ortanca olan değer her zaman orta değerdir.

Kontrol ediliyor : Soldaki element(S) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(B) Pivot(L) den küçük mü? ( Evet )

Soldaki element(0) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(E) Pivot(L) den küçük mü? ( Evet )

Soldaki element(R) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(I) Pivot(L) den küçük mü? ( Evet )

Soldaki element(T) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(P) Pivot(L) den küçük mü? ( Hayır )

Soldaki element(T) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(S) Pivot(L) den küçük mü? ( Hayır )

Soldaki element(T) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(I) Pivot(L) den küçük mü? ( Evet )

Soldaki element(E) Pivot(L) den büyük mü? ( Hayır )
Sağdaki element(E) Pivot(L) den küçük mü? ( Evet )

Soldaki element(R) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(E) Pivot(L) den küçük mü? ( Evet )

Soldaki element(R) Pivot(L) den büyük mü? ( Evet )
Sağdaki element(E) Pivot(L) den küçük mü? ( Evet )

B - E - I - I - I - E - E - L - R - T - S - P - R - O - S

B E E E I I I L O P R R S S T

function quicksort(array)
var list less, equal, greater
if length(array) ≤ 1
return array
select a pivot value pivot from array
for each x in array
if x < pivot then append x to less
if x = pivot then append x to equal
if x > pivot then append x to greater
return concatenate(quicksort(less), equal, quicksort(greater))

procedure bubbleSort( A : sıralanabilir öğe dizisi ) defined as:
do
swapped := false
for each i in 0 to length( A ) - 2 do:
if A[ i ] > A[ i + 1 ] then
swap( A[ i ], A[ i + 1 ] )
swapped := true
end if
end for
while swapped

procedure bubbleSort( A : sıralanabilir öğe dizisi ) defined as:
for each i in 1 to length(A) do:
for each j in length(A) downto i + 1 do:
if A[ j -1 ] > A[ j ] then
swap( A[ j - 1], A[ j ] )
end if
end for
end for
end procedure

Aşağıda C/C++ dilinde yazılmış, bir sayı dizisini kabuk sıralaması algoritmasını kullanarak sıralayan bir program verilmiştir.

/*

SHELL SORT
Written by erengencturk.net
*/


#include <stdio.h>

#define ELEMENTS 6

void shellsort(int A[],int max)
{
int stop,swap,limit,temp,k;
int x=(int)(max/2)-1;
while(x>0)
{
stop=0;
limit=max-x;
while(stop==0)
{
swap=0;
for(k=0;k<limit;k++)
{
if(A[k]>A[k+x])
{
temp=A[k];
A[k]=A[k+x];
A[k+x]=temp;
swap=k;
}
}
limit=swap-x;
if(swap==0)
stop=1;
}
x=(int)(x/2);
}
}

int main()
{
int i;
int X[ELEMENTS]={5,2,4,6,1,3};
printf("Unsorted Array:\n");
for(i=0;i<ELEMENTS;i++)
printf("%d ",X);

shellsort(X,ELEMENTS);
printf("\nSORTED ARRAY\n");
for(i=0;i<ELEMENTS;i++)
printf("%d ",X);

}

procedure cocktailSort( A : list of sortable items ) defined as:
do
swapped := false
for each i in 0 to length( A ) - 2 do:
if A[ i ] > A[ i + 1 ] then // ardışık iki öğenin doğru sırada olup olmadığına bak order
swap( A[ i ], A[ i + 1 ] ) // iki öğenin yerlerini değiştir
swapped := true
end if
end for
if swapped = false then
// eğer değişiklik yapılmadıysa dıştaki döngüden çıkabiliriz.
break do-while loop
end if
swapped := false
for each i in length( A ) - 2 to 0 do:
if A[ i ] > A[ i + 1 ] then
swap( A[ i ], A[ i + 1 ] )
swapped := true
end if
end for
while swapped // hiçbir öğe yer değiştirmediyse liste sıralanmıştır
end procedure

function bucket-sort(array, n) is
buckets ← new array of n empty lists
for i = 0 to (length(array)-1) do
insert array into buckets[msbits(array, k)]
for i = 0 to n - 1 do
next-sort(buckets)
return the concatenation of buckets[0], ..., buckets[n-1]