Sortowanie przez wstawianie
Sortowanie bąbelkowe
Sortowanie przez wstrząsanie
Sortowanie szybkie (Quicksort)
Sortowanie przez kopcowanie (Heap Sort)
Sortowanie przez scalanie

Na koniec powiemy sobie co nie co o tych sortowaniach. Tak więc zacznijmy

Sortowanie przez wstawianie

Cytat:

Ciekawa odmiana tego algorytmu realizuje wstawianie poprzez przesuwanie zawartości tablic w prawo o jedno miejsce w celu wytworzenia odpowiedniej luki, w której następnie umieszcza ów element. Skąd mamy wiedzieć, czy kontynuować przesuwanie zawartości tablicy podczas poszukiwania luki? Podjęcie decyzji umożliwi nam sprawdzanie warunku sortowania (sortowanie w kierunku wartości malejących, rosnących, czy też wg innych kryteriów).

Zobaczmy jak wygląda taki algorytm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<?php
function InsertSort(&$tab)
{
  $n = count($tab);
  for($i = 1; $i < $n;$i++)
  {
    $j = $i; // 0 i -1 są posortowane
    $temp = $tab[$j];
    while (($j > 0) && ($tab[$j-1]>$temp))
    {
       $tab[$j] = $tab[$j-1];
       $j--;
    }
    $tab[$j]=$temp;
  }
}
?>

Cytat:

Algorytm sortowania przez wstawianie charakteryzuje się dość wysokim kosztem: jest on bowiem klasy O(N²), co eliminuje go w praktyce z sortowania dużych tablic. Niemniej jeśli nie zależy nam na szybkości sortowania, a potrzebujemy algorytm na tyle krótkiego, by się w nim nie pomylić – to wówczas jest on idealny w swojej niepodważalnej prostocie.

Przykład użycia:

1
2
3
4
5

<?php
$tablica = array (2,3,7,9,10,6,8,4);
InsertSort($tablica);
print_r($tablica);
?>

Powinniśmy dostać taki o to rezultat:

1
2
3
4
5
6
7
8
9
10
11

Array
(
    [0] => 2
    [1] => 3
    [2] => 4
    [3] => 6
    [4] => 7
    [5] => 8
    [6] => 9
    [7] => 10
)

Sortowanie bąbelkowe

Cytat:

Podobnie jak sortowanie przez wstawianie, algorytm sortowania bąbelkowego charakteryzuje się olbrzymią prostotą zapisu. Intrygująca jego nazwa wzięła się z angielskich pęcherzyków powietrza, ulatujących w górę tuby wypełnionej wodą – i ole postawioną tablicę pionowo w górę potraktować jako pojemnik z wodą, a liczby jako pęcherzyki powietrza. Najszybciej ulatują do góry „bąbelki” najlżejsze -liczby o najmniejszej wartości (przyjmując oczywiście że sortowanie w kierunku wartości niemalejących).

A teraz trochę kodu

1
2
3
4
5
6
7
8
9
10
11
12
13
14

<?php
function BubbleSort(&$tab)
{
  $n = count($tab);
  for($i=1; $i < $n; $i++)
    for($j = count($tab)-1; $j>=$i; $j--)
      if($tab[$j]<$tab[$j-1])
      { // zmiana $tab[j-1] z $tab[$j]
        $tmp = $tab[$j-1];
        $tab[$j-1] = $tab[$j];
        $tab[$j] = $tmp;
      }
}
?>

Przykład użycia

1
2
3
4
5

<?php
$tablica = array (40,2,29,6,18,4,20);
BubbleSort($tablica);
print_r($tablica);
?>

Powinniśmy dostać taki o to rezultat:

1
2
3
4
5
6
7
8
9
10

Array
(
    [0] => 2
    [1] => 4
    [2] => 6
    [3] => 18
    [4] => 20
    [5] => 29
    [6] => 40
)

Analiza algorytmu (miała być tabelka, ale za dużo roboty xD)

Przeanalizujmy dokładnie sortowanie bąbelkowe pewnej 7-elementowej tablicy. Tablica jest przemiatana sukcesywnie od dołu do góry (pętla zmiennej $i). Analizowane są zawsze dwa sąsiadujące ze sobą elementy (pętla zmiennej $j): jeśli nie są one uporządkowane (u góry jest element „cięższy”), to następuje ich zmiana. W trakcie pierwszego rpzebiegu na pierwszą pozycje tablicy (indeks 0) ulatuje element „najlżejszy”, w trakcie drugiego przebiegu drugi najlżejszy element wędruje na drugą pozycję tablicy (indeks 1) i tak dalej, aż do ostatecznego posortowania tablicy. Strefa pracy algorytmu zmniejsza się zatem o 1 w kolejny przejściu dużej pętli – analizowane za każdym razem całej tablicy było by oczywistym marnotrawstwem!

Nawet dość pobieżna analiza prowadzi do kilku negatywnych uwag na temat samego algorytmu:

• dość często zdarzają się „puste przebiegi” (nie jest dokonywana żadna wymiana, bowiem elementy są już posortowane);
• algorytm jest bardzo wrażliwy na konfigurację danych. Oto przykład dwóch niewiele różniących się tablic, z których pierwsza wymaga jednej zmiany sąsiadujących ze sobą elementów, a druga będzie wymagać ich aż sześciu.
  1. 4, 2, 6, 18, 20, 39, 40
  2. 4, 6, 18, 20, 39, 40, 2

Istnieje kilka możliwości poprawy jakości tego algorytmu – nie prowadzą one co prawda do zmiany jego klasy (w dalszym ciągu mamy do czynienia z O(N²)), ale mimo to dość znacznie go przyspieszają. Ulepszenia te polegają odpowiednio na:

• zapamiętywaniu indeksu ostatniej zamiany (walka z „pustymi przebiegami”);
• przełączaniu kierunków przeglądania tablicy (walka z niekorzystnymi konfiguracjami danych);

Tak poprawiony algorytm sortowania bąbelkowego nazwiemy sobie po Polsku sortowaniem poprzez wytrząsanie (ang. shaker-sort).

Sortowanie przez wstrząsanie

Cały opis tego algorytmu jest zawarty w powyższym pkt + uwzględnione poprawki.

Skrypt:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

<?php
function zmiana(&$a, &$b)
{
  $tmp = $a;
  $a = $b;
  $b = $tmp;
}
 
function ShakerSort(&$tab)
{
  $left = 1;
  $n = count($tab);
  $right = $n-1;
  $k = $n-1;
  do
  {
    for($j = $right; $j >= $left; $j--)
      if($tab[$j-1] > $tab[$j])
      {
        zmiana($tab[$j -1],$tab[$j]);
        $k = $j;
      }
      $left = $k+1;
      for($j = $left; $j <= $right; $j++)
        if($tab[$j-1] > $tab[$j])
        {
          zmiana($tab[$j-1],$tab[$j]);
          $k = $j;
        }
      $right = $k-1;
  }while ($left < $right);
}
?>

Przykład użycia taki sam jak przy sortowaniu bąbelkowym, powinien dać taki sam rezultat.

Sortowanie szybkie (Quicksort)

Cytat:

Jest to słynny algorytm. Należy od do tych rozwiązań w których poprzez odpowiednią dekompozycję osiągnięty został znacznie zysk szybkości sortowania. Procedura sortowania dzieli się na dwie zasadnicze części: część służącą do właściwego sortowania, która nie robi w zasadzie nic oprócz wywoływania samej siebie, oraz procedury rozdzielania elementów tablicy względem wartości pewnej komórki tablicy służącej za oś (ang. pivot) podziału. Proces sortowania jest dokonywany przez tą właśnie procedurę, natomiast rekurencja zapewnia poskładanie wyników cząstkowych i w konsekwencji posortowanie całej tablicy.

Jak dokładnie działa procedura podziału? Otóż w pierwszym momencie odczytuje się wartość elementu osiowego P, którym zazwyczaj jest po prostu pierwszy element analizowanego fragmentu tablicy. Tenże fragment tablic jest następnie dzielony wg klucza symbolicznie podstawionego poniżej:

Kolejnym etapem jest zaaplikowanie procedury Quicksort na lewym i prawym fragmencie tablicy, czego efektem będzie jej posortowanie. To wszystko!

Cały pomysł opiera się na zachowaniu dość prostego niezmiennika w aktualnie rozdzielanym fragmencie tablicy

Oznaczenia:
• left – lewy skrajny indeks aktualnego fragmentu tablicy;
• right – prawy skrajny indeks aktualnego fragmentu tablicy;
• P – wartość osiowa (zazwyczaj będzie to $tab[$left]);
• i – indeks przechadzający się po indeksach tablicy od left do right;
• m – poszukiwany indeks komórki tablicy, w której umieścimy element osiowy

Cytat:

Przemieszczanie się po tablicy służy do poukładani jej elementów w taki sposób, aby po lewej stronie m, znajdowały się wartości mniejsze od elementu osiowego, po prawej zaś – większe lub równe. W tym celu podczas przemieszczania indeksu i sprawdzimy prawdziwość niezmiennika $tab[i] > P. Jeśli jest on fałszywy, to poprzez inkrementację i wymianę wartości $tab[m] i $tab[i] przywracamy porządek. Gdy zakończymy ostatecznie przeglądanie tablicy w pogoni za komórkami, które nie chciały się podporządkować niezmiennikowi, zamiana $tab[$left] i $tab[m] doprowadzi do oczekiwanej sytuacji.

Pokażmy teraz jak to działa:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
function zmiana(&$a, &$b)
{
  $tmp = $a;
  $a = $b;
  $b = $tmp;
}
 
function Quicksort (&$tab, $left, $right)
{
  if($left < $right)
  {
    $m = $left;
    for($i = $left+1; $i <= $right; $i++)
      if($tab[$i] < $tab[$left])
      {
        zmiana($tab[++$m],$tab[$i]);
      }
    zmiana($tab[$left],$tab[$m]);
    Quicksort($tab,$left,$m-1);
    Quicksort($tab,$m+1,$right);
  }
}
?>

Przykład zastosowania:

1
2
3
4
5
6

<?php
$tablica = array (29,40,2,1,6,18,20,32,23,34,39,41);
$prawa = count($tablica)-1;
Quicksort($tablica,0,$prawa);
print_r($tablica);
?>

Powinniśmy dostać taki o to rezultat:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Array
(
    [0] => 1
    [1] => 2
    [2] => 6
    [3] => 18
    [4] => 20
    [5] => 23
    [6] => 29
    [7] => 32
    [8] => 34
    [9] => 39
    [10] => 40
    [11] => 41
)

cdn…