Shel sort - algortim de sortare

Shel sort - algortim de sortare

   Astazi mi-am propus sa vorbim despre un algoritm de sortare ceva mai special fata de cel precedent, insertion sort. Algoritmul a fost descoperit in 1959 de D. L. Shell - de aici provine si denumirea de "Shell sort". Practic, algoritmul este o generalizare a insertion sort.

Descrierea algoritmului

   In etapele de inceput se sorteaza subsiruri din cel principal, aceste subsiruri au elementele la o distanta prestabilita. In etapele de inceput numarul acestor subsiruri este mare, dar acestea contin putine elemente. Pe masura ce avansam, numarul subsirurilor se imputineaza, dar numarul elementelor acestor subsiruri creste. Intr-un final vom ramane doara cu un sir, iar de aici se aplica algortimul de insertion sort clasic.

Sa nu o mai lungim si s atrecem la un exemplu practic:

Sa luam sirul:

6, 5, 4, 3, 2, 1 

   Dupa cum spuneam, se va face sortare pe mai multe subsiruri. Cum stabilim numarul de subsirurilor de inceput? Stabilind distanta dintre elemente la fiecare cilclu. Conform autorului, la inceput acest interval va avea valoarea [n/2], n reprezinta numarul de elemente ale sirului, iar prin [ si ] reprezentam partea intrega a acelui numar. Ai uitat ce reprezinta partea intreaga?

Partea intreaga reprezinta valoarea din partea stanga a virgulei, partea intreaga a numarului 6.5 este 6, partea intreaga a numarului 8.999999 este 8.

Pe masura ce inaintam spre un alt ciclu injumatatim aceasta valoare, adica la al doilea ciclu al buclei valoarea acestui interval va fi [[n/2]/2],  adica am injumatatit valoarea intervalului de la ciclul precedent si i-am luat partea intreaga. 

   Sirul nostru contine 6 elemente, deci distanta dintre elemente va fi de [6/2] = 3. Acestea sunt intervalele: 

6, 5, 4, 3, 2, 1

6, 5, 4, 3, 2, 1

6, 5, 4, 3, 2, 1

Aplicam algortimul clasic de insertion sort pe fiecare dintre aceste 3 siruri, incepem cu primul:

6, 5, 4, 3, 2, 1

Sirul sortat contine elementul 6, il vom compara pe 3 cu fiecare element din sirul sortat pentru a stabili unde il inseram. Deoarece sirul sortat al subsirului format din 6 si 3 contine doar elementul 6 il vom compara pe 3 cu 6. Deoarece 6 este mai mare ca 3, acestea vor schimba pozitiile. Asa arata subsirul 1 acum:

3, 5, 4, 6, 2, 1 

Elementele ce compun subsirul 1, 3 si 6, sunt in ordine. Avansam la urmatorul subsir, cel format din elementele 5 si 2.

3, 5, 4, 6, 2, 1

Aplicam algorimul clasic de insertion sort pe acest subsir. 5 este mai mare ca 2? Da, deci acestea vor interschimba pozitiile. Asa arata subsirul 2 acum:

3, 2, 4, 6, 5, 1

Si cel de al doilea sir este sortat, elementele  ce compun sirul, 2 si 5, sunt in ordine. Trecem la ultimul subsir:

3, 2, 4, 6, 5, 1

4 este mai mare decat 1? Da! Deci elementele 4 si 1 vor interschimba pozitiile. Asa arata subsirul nostru acum:

3, 2, 1, 6, 5, 4

Intr-un final, puteam observa ca am sortat toate cele 3 subsiruri:

3, 2, 1, 6, 5, 4

3, 2, 1, 6, 5, 4

3, 2, 1, 6, 5, 4

Acum ca am sortat toate cele 3 sirui, vom injumatati valoarea intervalului extragand doar partea intreaga din acesta: [[6/2]/2] - dar cine este [6/2]? 3. Deci [3/2] = 1. Daca distanta dintre elemente este 1, atunci avem doar un singur subsir - intrucat distanta dintre elementele acestui subsir este 1. Deci, subsirul nostru este:

3, 2, 1, 6, 5, 4  

Dar subsirul nostru este chiar sirul principal pe care vrem sa-l sortam, de aici aplicam algortimul clasic de insertion sort. Incepem de la elementul de indice 1, deci:

3, 2, 1, 6, 5, 4

Il comparam pe 2 cu fiecare element din lista sortata, care este compusa doar din 3 la a acest moment. Deci, 3 este mai mare ca 2? Da! acestea doua vor interschimba pozitiile. Sirul nostru va arata asa:

2, 3, 1, 6, 5, 4

Trecem la urmatorul element, 1, si-l vom compara cu fiecare elemnt din lista sortata pentru a decide unde-l vom insera. 

2, 3, 1, 6, 5, 4

3 este mai mare ca 1? Da. 3 si 1 vor schimba pozitiile.

2, 1, 3, 6, 5, 4

2 est mai mare ca 1? Da. 2 si 1 vor schimba pozitiile.

1, 2, 3, 6, 5, 4

Pentru a sorta sirul in continuare trebuie doar sa continui sa aplici insertion sort - despre care am vorbit in ultimele 2 tutoriale.

Sa luam sirul format din elementele:

8, 7, 6, 5, 4, 3, 2, 1

Pentru inceput vom aveam [8/2] - deoarece sirul are 8 elemente, n=8 - deci intervalul dintre elementele primelor subsiruri va fi 4. Iata subsirurile:

8, 7, 6, 5, 4, 3, 2, 1

8, 7, 6, 5, 4, 3, 2, 1

8, 7, 6, 5, 4, 3, 2, 1

8, 7, 6, 5, 4, 3, 2, 1

Vom aplica algortimul de insertion sort pe fiecare dintre aceste subsiruri. Incepem cu primul:

8, 7, 6, 5, 4, 3, 2, 1

Tot ce avemd e facut este sa aplicam algortimul de insertion sort pe sirul ce contine elementele  8 si 4. 8 va fi primul element al sirului sortat, deci il vom compara pe 4 cu 8 pentru a decide unde-l inseram pe 4. 8 este mai mare ca 4, deci 8 si 4 vor schimba pozitiile.

4, 7, 6, 5, 8, 3, 2, 1

Primul subsir este sortat, trecem la urmatorul.

4, 7, 6, 5, 8, 3, 2, 1

Il vom compara pe 3 cu 7 - elementul ce compune sirul sortat al subsirului format din elementele 7 si 3. 7 este mai mare decat 3, deci aceste vor schimba pozitiile.

4, 3, 6, 5, 8, 7, 2, 1

Cel de al doilea subsir este sortat, trec la al treilea.

4, 3, 6, 5, 8, 7, 2, 1

6 este mai mare ca 2? Da. 2 si 6 vor schimba pozitiile.

4, 3, 2, 5, 8, 7, 6, 1

Si cel de al treilea subsir este sortat, trecem la ultimul.

4, 3, 2, 5, 8, 7, 6, 1

5 este mai mare ca 1? Da! Deci 5 si 1 vor schimba pozitiile.

4, 3, 2, 1, 8, 7, 6, 5

Am sortat toate cele 4 subsiruri, acum putem sa injumatatim valoarea intervalului. Deci, [4/2]=2. Distanta dintre elementele sirurilor ce se vor forma este de 2. Acestea sunt subsirurile:

4, 3, 2, 1, 8, 7, 6, 5

4, 3, 2, 1, 8, 7, 6, 5

Incepem cu primul subsir, cel format din elementele: 4, 2, 8, 6. Sirul sortat este format din elementul 4, vom compara fiecare element din sirul nesortat cu fiecare din sirul sortat pentru a decide unde-l inseram. 

4, 3, 2, 1, 8, 7, 6, 5

Il comparam pe 2 cu 4. 4 este mai mare ca 2, deci aceste elemente vor schimba pozitiile.

2, 3, 4, 1, 8, 7, 6, 5

Trecem la urmatorul element, 8:

2, 3, 4, 1, 8, 7, 6, 5

Nu este niciun element mai mare ca 8 in sirul sortat, deci trecem mai departe la elementul 6.

2, 3, 4, 1, 8, 7, 6, 5

8 este mai mare ca 6? Da. deci 8 si 6 ar trebuis a schimbe pozitiile.

2, 3, 4, 1, 6, 7, 8, 5

Am sortat primul subsir, mai trebuie sa-l sortam pe al doilea:

2, 3, 4, 1, 6, 7, 8, 5

Incepem cu elementul 1, il vom compara cu fiecare elemnt din sirul nesortat - compus, deocamdata, doar din 3. 3 este mai mare ca 1? Da. Deci 3 si 1 ar trebui sa schimbe pozitiile.

2, 3, 4, 1, 6, 7, 8, 5

2, 1, 4, 3, 6, 7, 8, 5

Urmeaza sa-l comparam pe 7 cu elementele din sirul sortat pentru a stabili unde-l inseram.

 2, 1, 4, 3, 6, 7, 8, 5

Deoarece niciun element nu este mai mare ca 7, acesta isi va pastra pozitia. Trecem la elementul 5.

 2, 1, 4, 3, 6, 7, 8, 5

7 este mai mare ca 5, deci 5 si 7 ar trebuis a schime pozitiile. Sirul nostru arata asa acum:

2, 1, 4, 3, 6, 5, 8, 7

Am sortat cele doua subsiruri, acum putem sa mergem mai departe injumatatind valoarea intervalului. Deci, [2/2] = 1. Cum valoarea intervalului este 1, insemana ca de aici vom avea doar un sigur subsir:

2, 1, 4, 3, 6, 5, 8, 7

Pentru a-l sorta pe acesta vom aplica algortimul e insertion sort clasic. Incepem cu elementul 1, il comparam cu restul elementelor din lista sortata pentru a decide unde-l inseram. Apoi continuam cu elementul 4, repedem procedeul si mergem mai departe cu urmatorul element pana cand sirul este sortat.

Observa ca numarul de subsirui este egal cu valoaera fiecarui interval!

Impelementatia algoritmului

for(gap = n/2; gap > 0; gap /= 2) {
        for(i = gap; i < n; i++) {
            for(j = i - gap; j >= 0 && v[j] > v[j + gap]; j -= gap) {
                temp = v[j + gap];
                v[j + gap] = v[j];
                v[j] =  temp;
            }
        }
    }

   Vom implementa algortimul in limbajul C:

Pe linia 1 avem o bulca for ce initializeaza variabila gap cu valoarea n/2 si va rula pana cand variabila gap va lua valoarea 1 - intrucat conditia ne impune ca gap sa fie strict mai mare ca 0. la fiecare etapa injumatatim valoarea lui gap. Iti este familiara aceasta variabila gap? Exact, aceasta variabila gap este acel interval despre care am discutat mai sus. Probabil te intrebi de ce nu luam partea intreaga  a valorii n/2 inainte de a o stoca in gap. Nu este nevoie, intrucat variabila gap este de tipul intreg, iar acest tip de data nu poate retine numere cu virgula(reale).

Pe linile ce urmeaza avem generalizarea algortimului e insertion sort. Astfel, poti observa ca pe aceste linii sortam elementele aflate la gap distanta. Cand gap va lua valoarea 1, atunci nu vom face decat un insertion sort clasic.

Pe  liniile 4, 5 si 6  interschimbam valoarea elementului curent cu cea a a celui precedent in interval. Aceasta secventa este metoda clasica de swap.

Algoritmul de insertion sort

Insertion sort - algortim de sortare(partea I)

     Algoritmul de insertion sort este, probabil, unul dintre cei mai cunoscuti algortimi de sortare intrucat este usor de invatat, iar stapanirea acestuia este un criteriu obligatoriu ce trebuie indeplinit de oricine vrea sa inteleaga algortimi mai complexi derivati din acesta - precum shell sort despre care vom discuta intr-un alt articol.

   Mi-am propus sa va descriu modul de functionare al algortimului, apoi va voi arata implementatia acestuia in 3 limbaje de programare urmand sa va descriu codul de pe fiecare linie.

Descrierea Algoritmului

   Algoritmul presupune formarea unei liste sortate, apoi compararea fiecarui element din lista principala - adica cea nesortata - cu fiecare element din lista nesortata. In functie de aceste comparatii vom decide unde sa inseram elementul curent astfel incat lista sortata sa ramana in continuare sortata. Algoritmul s-ar putea sa va fie destul de familiar, intrucat este modul natural al oamenilor de a sorta lucrurile. Ganditi-va ca vreti sa plasati o carte intr-un pachet de carti astfel incat acesta sa fie in ordine. Cum procedati? Ei bine, comparati cartea in cauza cu fiecare dintre cele aflate deja in pacahet si o introduceti in locul unde apartine in functie de rezultatul acestor coparatii.

    Sa exemplificam modul de functionare. Considerati lista neordonata de numere:

2, 1, 3, 4

    Vom considera ca lista sortata contine doar elementul 2. Deci, vom incepe sa luam fiecare element incepand cu elementul 1 si le vom compara cu fiecare element din lista sortata adaugandu-l pe baza acestor comparatii in lista sortata.

Deci, comparam elementul 1 cu fiecare din lista sortata:

 2, 1, 3, 4

Cum, deocamdata, lista sortata este compusa doar din elementul 2, il vom compara pe 1 cu 2. 2 este mai mare ca 1, deci ar trebui sa le schimbam pozitiile intre ei astfel:

                                                                           2, 1, 3, 4

                                                                           1, 2, 3, 4

Dupa cum vedeti, elemente 1 si doi si-au schimbat pozitiile intre ele. acum lista noastra ordonata contine elementele: 1, 2. Trecem la urmatorul element, 3, si-l vom compara cu fiecare element din lista ordonata:

                                                                           1, 2, 3, 4

Doi este mai mare ca 3? Nu. Deci, nu mai are sens sa-l comparam pe 3 si cu celelalte elemente din lista ordonata intrucat daca 2 - numarul cel mai mare la acest momenet din lista ordonata - nu este mai mare ca 3, atunci nici 1 nu va fi mai mare ca 3. Asa ca 3 isi pastreaza pozitia. Lista ordonata arata astfel: 1, 2, 3. Trecem la urmatorul element.

                                                                          1, 2, 3, 4

Il vom compara pe 4, pe rand, cu fiecare element din lista ordonata. 3 este mai mare ca 4? Nu. Deci nu mai are sens sa-l comparam si cu celelalte. 4 isi pastreaza pozitia.

Dupa cum puteti vedeam am sortata lista.

Sa luam un alt exemplu:

3, 4, 2, 1

Lista sortata contine elementul 3. Vom compara fiecare element din lista nesortata cu fiecare din lista sortata. 

3, 4, 2, 1

Ia sa vedem. 3 este mai mare decat 4? Nu. Deci, 4 isi pastreaza pozitia. Lista sortata arata acum astfel: 3, 4. Trecem, la urmatorul element:

                                                                          3, 4, 2, 1

Il vom compara pe doi cu fiecare element din lista sortata. 4 este mai mare decat 2? Da. Deci 4 ar trebui sa treaca pe pozitia lui 2 iar doi pe pozitia lui patru:

                                                                         3, 4, 2, 1

                                                                         3, 2, 4, 1

Dupa cum spuneam, il comparam pe doi cu fiecare element din lista sortata, dar a mai ramas 3. Deci, 3 este mai mare ca doi? Categoric da. Deci, 3 ar trebui sa treaca pe pozitia lui 2 si 2 pe pozitia lui 3.

                                                                         3, 2, 4, 1

                                                                        2, 3,  4, 1

L-am comparat pe doi cu fiecare element din lista sortata pana am putut stabili cu exactitate pozitia lui in lista.  Lista noastra sortata ara asa acum: 2, 3, 4. Acum puteam trece la urmatorul element, 1.

                                                                         2, 3, 4, 1

Il vom compara pe 1 cu fiecare element din lista sortata. 4 este mai mare ca 1? Da! deci 4 si 1 ar trebui sa schimbe pozitiile intre ei.

                                                                         2, 3, 4, 1

                                                                         2, 3, 1, 4

Il comparam pe 1 cu urmatorul element din lista sortata. 3 este mai mare ca 1? Da, da, da. deci 3 si 1 ar trebui sa schimbe pozitiile intre ei.

                                                                         2, 3, 1, 4

                                                                         2, 1, 3, 4

Il comparam pe 1 cu ultimul element din lista sortata pentru a vedea daca ii mai schimbam pozitia sau daca va rama acolo unde este. 2 este mai mare decat 1? Da. deci 2 si 1 ar trebui sa schimbe pozitiile intre ei.

                                                                        2, 1, 3, 4

                                                                        1, 2, 3, 4

Intr-un final, avem o lista sortata(crescator).

Probabail ca ati remarcat ca aceasta "lista ordonata/sortata" de care tot aduc vorba face parte din lista principala pe care vrem sa o sortam. Este doar un concept abstract folosit pentru a explica mult mai bine modul de functionare al algoritmului.

Implementatia algortimului

   Nu ne mai ramane decat sa implementam acest algortim intr-un limbaj de programare. Din motive obiective il voi implemeneta in 3 limbaje: C, Python si PHP.

Sa incepem cu implementatia in C:

for(i = 0; i < n; i++) {
        currentElement = v[i];
        for(j = i - 1; j >= 0; j--) {
            if(currentElement < v[j]) {
                v[j + 1] = v[j];
                v[j] = currentElement;
            }
            else {
                break;
            }
        }
    }

Pe linia 1 aveam o bucla for ce va duce variabila de ciclare i de la valoarea 1 la n-1. De ce incepem de la 1? Pentru ca primul element al array-ului va reprezenta lista sortata. Aminteste-ti ca array-urile sunt indexate de la 0. 

Pe linia 2 salvam valoarea aflata in elementul v[i], deci elementul de indice i in variabila currentEelement. 

Pe linia 3 avem o bucla for in care initializam variabila de ciclare j cu valoarea i-1. Cine este elementul de indice i-1? Exact elementul din spatele celui curent, deci primul element din lista sortata - daca ar fi sa numaram de la stanga la dreapta. Punem conditia ca bucla sa ruleze pana cand j ia(inclusiv) valoarea 0. La fiecare etapa a buclei decrementam variabila j cu o unitate.

Pe linia 4 verificam daca elementul de indice j este mai mare decat elementul curent. Cine este acest element de indice j? Exact, elementul din spatele lui currentEelement. In cazul in care elementul de indice j este mai mare decat currentElement trecem pe ramura de adevar(TRUE) a if-ului.

Pe linia 5 "spunem" ca pozitia j+1 din array va fi ocupata de elementul de pe pozitia j.  Atentie! Cine este elementul de pe pozitia j+1 ? Elementul curent. Deoarece am salvat valoarea elementului curent in variabila currentElement aceasta nu este pierduta.

Pe linia 6 ocupam pozitia j a array-ului cu valoarea salvata in variabila currentElement. Practic, pe aceste doua linii de cod, 5 si 6, am interschimbat pozitia elementului curent cu cea a elementului din lista ordonata ce este mai mare ca acesta. Acest procedeu se va repeta pana cand nu va mai fi niciun element in lista ordonata mai mare decat cel curent.

Pe linia 7 oprim cea de a doua bucla. Intrucat am patruns pe ramura else a if-ului, deci nu mai sunt elemente mai mari decat cel curent in lista ordonata.

Desigur, am fi putut sa evitam utilizarea constructului break prin alterarea conditiei din cea de a doua bucla. Dar am considerat ca ar fi mult mai usor de inteles asa.