Sortare bazată pe comparații

Sortare prin interschimbare Sortare prin inserție

Procedure bubbleSort(a, n) Procedure insertSort(a, n)
begin begin
ultim ← n − 1 for i ← 1 to n − 1 do
while (ultim > 0) do j ← i–1
n1 ← ultim–1; ultim ← 0 temp ← a[i]
for i ← 0 to n1 do while ((j ≥ 0) and (a[j] > temp)) do
if (a[i] > a[i + 1]) then a[j + 1] ← a[j]
swap(a[i], a[i + 1]) j ← j–1
ultim ← i if (a[j + 1]! = temp) then
end a[j + 1] ← temp
end

Sortare prin selecție (naivă)

Procedure naivSort(a, n)
begin SORTARE PRIN SELECȚIE SISTEMATICĂ: 2 ETAPTE
for i ← n − 1 downto 1 do
imax ← i
for j ← i − 1 downto 0 do
if (a[j] > a[imax]) then
imax ← j
if (i! = imax) then
swap(a[i], a[imax])
end

Etapa 1 Etapa 2
Procedure insereazaAlTlea(a, n, t) Procedure heapSort(a, n)
begin begin
j←t // construiește maxheap-ul
heap ← false for t ← (n − 1)/2 downto 0 do
while ((2 ∗ j + 1 < n) and not heap) do insereazaAlTlea(a, n, t)
k←2∗j+1 // elimină
if ((k < n − 1) and (a[k] < a[k + 1])) then r←n−1
k←k+1 while (r > 0) do
if (a[j] < a[k]) then swap(a[0], a[r])
swap(a[j], a[k]) insereazaAlTlea(a, r, 0)
j←k r←r−1
else end
heap ← true
end

Sortare prin interclasare (merge sort)

Procedure mergeSort(a, m, b, n)
begin
i ← 0; j ← 0; k ← 0
while ((i < = m-1) and (j < = n-1)) do
if (a [ i ] < = b [ j ]) then
c[k]←a[i]
i←i+1
else if (a [ i ] > b [ j ]) then
c[k]←b[j]
j←j+1
k←k+1

end
Sortare rapidă (quick sort)
Procedure partitioneaza(a, p, q, k) Procedure quickSort(a, p, q)
begin begin
x←a[p] while (p < q) do
i←p+1 partitioneaza(a, p, q, k)
j←q quickSort(a, p, k− 1)
while (i < = j) do quickSort(a, k + 1, q)
if (a [ i ] < = x) then end
i←i+1
 if ( a [j ] > = x ) then
j←j−1
if (i < j) and (a [ i ] > x)
and (x > a [j ] ) then
swap ( a [ i ] , a [j])
i←i+1
j←j−1
k←i−1
a[p]←a[k]
a[k]←x
end

Sortare prin numărare Sortare prin distribuție

Procedure countingSort(a, b, n, k) Procedure bucketSort(a, n)
begin begin
for i ← 1 to k do for i ← 0 to n − 1 do
c[i] ← 0 insereaza(B[ [n · a[i]] ], a[i])
for j ← 0 to n − 1 do for i ← 0 to n − 1 do
c[a[j]] ← c[a[j]] + 1 sortează lista B[i]
for i ← 2 to k do concatenează în ordine listele B[0], B[1], · · · , B[n − 1]
c[i] ← c[i] + c[i − 1] end
for j ← n − 1 downto 0 do
b[c[a[j]] − 1] ← a[j]
c[a[j]] ← c[a[j]] − 1
end