Universitatea Transilvania din Bras, ov

Facultatea de Matematică s, i Informatică

Departamentul de Matematică s, i Informatică
.
.

Redactare s, i comunicare s, tiint, ifică s, i

profesională
REFERAT

Autor: Sı̂rboiu Filip

Informatică Aplicată, Anul I
Grupa 10LF323
 Sortarile
Contents
1 QuickSort 2
1.1 Implementarea pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Complexitatea algoritmului . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Exemplu pe un vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2 BubbleSort 4
2.1 Implementarea pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Complexitatea algoritmului . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Exemplu pe vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3 InsertSort 6
3.1 Implementarea pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.2 Complexitatea algoritmului . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
3.3 Exempleu pe vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 SelectSort 7
4.1 Implementarea pseudocode . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.2 Complexitatea alogritmului . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.3 Exemplu pe un vector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Sortarea
O altă subproblemă des ı̂ntâlnită ı̂n programare este sortarea. Un algoritm de
sortare este un algoritm alcătuit dintr-o serie de intruct, iuni care au ca date de intrare o
structură de date (unidimensională,bidimensională,etc), efectuează diverse operat, ii asupra
structurii respctive s, i au ca date de ies, ire o structură sortată după un anumit criteriu. Ex-
istă mult, i factori pe care trebuie să-i luăm ı̂n considerare atunci când alegem să utilizăm
un algoritm de sortare, printre care eficient, a (timpul de execut, ie si memoria folosită) si
stabilitatea. Fiind o problemă des ı̂ntâlnită, se pot observa diverse implementări ale algo-
ritmilor de sortare ı̂n limbajele de programare pe care le utilizăm (de exemplu: ı̂n C++
avem sort-ul din STL).

Stabilitate.O metodă de sortare este considerată stabilă dacă ordinea relativă a ele-
mentelor ce au aceeas, i valoare a cheii s, i nu se modifică ı̂n procesul de sortare.
Naturalet, e. O metodă de sortare este considerată naturală dacă numărul de operat, ii
scade odată cu distant, a dintre tabloul init, ial s, i cel sortat. O măsură a acestei distant, e
poate fi numărul de inversiuni al permutării corespunzătoare tabloului init, ial.
Eficientă. O metodă este considerată eficientă dacă nu necesită un volum mare de resurse.
Din punctul de vedere al spat, iului de memorie o metodă de sortare pe loc este mai efi-
cientă decât una bazată pe o zonă de manevră de dimensiunea tabloului. Din punct de
vedere al timpului de execut, ie este important să fie efectuate cât mai put, ine operat, ii.
În general, ı̂n analiză se iau ı̂n considerare doar operat, iile efectuate asupra elementelor
tabloului (comparat, ii s, i mutări). O metodă este considerată optimală dacă ordinul său de
complexitate este cel mai mic din clasa de metode din care face parte.
Simplitate. O metodă este considerată simplă dacă este intuitivă si us, or de ı̂nt, eles.

1
După cum bine s, tim, fiecare algoritm de sortare are nevoie de un anumit spat, iu s, i un
anumit timp pentru executarea algoritmului. Pentru măsurarea complexităt, ii vom folosi
notat, ia complexităt, ii O(n) (n reprezintă numărul de comparat, ii ale algoritmului).
Cazul Mediu - situat, ia in care probabilitatea duratei execut, iei algoritmului se apropie
de media timpului de execut, ie al algoritmului respectiv.
Cazul defavorabil - situat, ia in care timpul de execut, ie al algoritmului este cel mai ridi-
cat.
Memorie folosită – memoria necesară sortării vectorului.

Tipuri de sortări:

1. BubbleSort

2. InsertSort

3. SelectSort

4. CountSort

5. QuickSort

6. MergeSort

7. HeapSort

8. ShellSort

9. ShakerSort

10. BucketSort

1 QuickSort
Datorită performant, elor sale deosebite, algorituml QuickSort este unul dintre cei mai
utilizat, i algoritmi de sortare până ı̂n acest moment, bazându-se pe tehnica ”Divide et
Impera”. Quick Sort este un algortim ce poate fi descris foarte simplu la modul teoretic,
ı̂nsă scrierea acestuia sub formă de cod sursă a pus ı̂ntotdeauna probleme. Cercetătorii
din domeniul informaticii au avut nevoie de ani de zile pentru a obt, ine o implementare
practică a acestui algoritm.
Sortarea rapidă se realizează ı̂ntr-o funct, ie care, aplicată unui s, ir de numere, piozit, ionează
un element din s, ir, ”pivot”, pe pozit, ia finală, pe care se va afla acesta ı̂n s, irul sortat, s, i
deplasează elementele din s, ir mai mici decât acesta ı̂n fat, a sa, iar pe cele mari după el.
Procedeul se reia pentru fiecare din cele două subs, iruri care au rămas neordonate.

Algoritmul se poate descrie ı̂n următoarele etape:

Etapa Divide:Vectorul X, format din elementele aflate ı̂ntre indicii i şi j, notat ı̂n contin-
uare X[i..j], este ı̂mpărţit ı̂n doi subvectori X[i ..m] şi X[m+1 ..j], fiecare subvector având
cel puţin un element şi fiecare element din primul subvector fiind mai mic sau egal decât
oricare element din cel de-al doilea subvector.
Etapa Impera:Cele două părţi sunt sortate apelând recursiv, până când se ajunge la
subvectori formaţi dintr-un singur element.
CombinareaAvând ı̂n vedere că fiecare subvector este sortat şi că cel mai mare element
din subvectorul stâng este mai mic decât cel mai mic element dinsubvectorul drept, atunci

2
ı̂ntregul vector va fi sortat.

Cea mai importantă etapă este cea de partiţionare. Există mai multe moduri ı̂n care
se poate ı̂mpărţi vectorul, dar următorul algoritm, inventat de R. Sedgevvick, pare a fi
cel mai bun: se porneşte de la ambele capete, folosind doi indicatori, i pentru partea
stângă şi j pentru partea dreaptă, căutându-se elementele care ar trebui să fie ı̂n cealaltă
parte; ı̂n momentul ı̂n care se găsesc două elemente care nu sunt ı̂n ordinea dorită şi dacă
iinterschimbă şi se continuă algoritmul; altfel, algoritmul ı̂ntoarce valoarea lui j; element
de referinţă se consideră ca fiind primul element din vector.

1.1 Implementarea pseudocode

Algoritmul 1 Quicksort
1: procedure quicksort(A, l, r)
2: if l < r then
3: p ← partition(A, l, r)
4: quicksort(A, l, p − 1)
5: quicksort(A, p + 1, r)
6: procedure partition(A, l, r)
7: pivot ← A[r]
8: i←l−1
9: for j ← l to r − 1 do
10: if A[j] ≤ pivot then
11: i←i+1
12: swap(A[i], A[j])
13: swap(A[i + 1], A[r])
14: return i + 1

1.2 Complexitatea algoritmului

1. timp mediu: O(n ∗ logn)

2. timp la limită: O(n2 )

3. memorie: O(log(n))

4. Stabil: NU

3
1.3 Exemplu pe un vector

2 BubbleSort
Metoda de sortare BubbleSort porneşte de la o proprietate evidentă a unui şir sortat:
oricare două elemente alăturate respectă relaţia de ordine. Astfel, dacă oricare pereche
de elemente alăturate respectă relaţia de ordine, atunci, conform tranzitivităţii relaţiei,
ı̂ntreg şirul va fi ordonat. Cele două elemente consecutive ale şirului de sortat vor forma
“bulele” pe care se va verifica relaţia de ordine cerută. Este cea mai simplă metodă de
sortare şi nu necesită cunoaşterea detaliată a limbajului de programare.

Se parcurge vectorul de sortat şi se compară elementele consecutive. Dacă acestea

nu se află ı̂n ordinea dorită, se interschimbă. Când se va ajunge la ultimul element al
vectorului, parcurgerea se reia şi se vor verifica din nou elementele vecine, cu realizarea
interschimbărilor acolo unde sunt necesare, până când, la o ultimă parcurgere nu mai este
necesară nici o interschimbare, prin urmare, vectorul este ordonat.
Se va folosi o variabilă de tip logic, care va marca dacă la o parcurgere se fac interschimbări
(se iniţializează la ı̂nceputul parcurgerii, iar dacă se face măcar o interschimbare, i se va
schimba valoarea). Algoritmul se opreşte atunci când această variabilă ı̂şi păstrează val-
oarea primită la ı̂nceputul parcurgerii (nu au mai fost necesare interschimbări).

2.1 Implementarea pseudocode

4
Algoritmul 2 BubbleSort
1: repeat
2: ok←fals;
3: for i←1,n-1 do
4: if x[i]>x[i+1] then
5: aux=x[i]
6: x[i]=x[i+1]
7: x[i+1]=aux
8: ok←adevărat
9: until ok=false

2.2 Complexitatea algoritmului

1. timp mediu: O(n2 )

2. timp la limită: O(n2 )

3. memorie: O(1)

4. Stabil: DA

2.3 Exemplu pe vector

Fie vectorul x=5, 8, 4, 7, 6

i x[1] x[2]x[3] x[4] x[5]

x[1],x[2] 5 8 4 7 6
Compar 5 cu 8: ordinea e cea dorită
x[2],x[3] 5 8 4 7 6
Compar 8 cu 4: ordinea nu e cea dorită; se interschimbă
x[3],x[4] 5 4 8 7 6
Compar 8 cu 7: ordinea nu e cea dorită ; se interschimbă
x[4],x[5] 5 4 7 8 6
Compar 8 cu 6: ordinea nu e cea dorită ; se interschimbă ; se reia parcurgerea
x[1],x[2] 5 4 7 6 8
Compar 5 cu 4: ordinea nu e cea dorită ; se interschimbă ;
x[2],x[3] 4 5 7 6 8
x[3],x[4] 4 5 7 6 8
x[4],x[5] 4 5 6 7 8
La următoarea parcurgere, nu se mai realizează interschimbări

5
3 InsertSort
Vom căuta poziţia pe care se inserează elementul vectorului la pasul i. Se parcurge vectorul
de la stânga la dreapta pentru a găsi un element mai mare decât cel curent. Căutarea se
face printre elementele deja ordonate (până la poziţia i – 1). Dacă se găseşte un element
mai mare, se vor deplasa dreapta cu o poziţie toate elementele de la el până la i-1 pentru
a face loc elementului i, care va fi inserat ı̂n poziţia corectă. Dacă nu există nici un
element mai mare decât elementul i, atunci acesta rămâne pe poziţia lui, subşirul fiind
deja ordonat.

3.1 Implementarea pseudocode

Algoritmul 3 Insertion Sort

1: procedure InsertionSort(A)
2: for i ← 1 to n − 1 do
3: key ← A[i]
4: j ←i−1
5: while j ≥ 0 and A[j] > key do
6: A[j + 1] ← A[j]
7: j ←j−1
8: A[j + 1] ← key

3.2 Complexitatea algoritmului

1. timp mediu: O(n2 )

2. timp la limită: O(n2 )

3. memorie: O(1)

4. Stabil: DA

3.3 Exempleu pe vector

Fie vectorul x=5,3,4,7,6

i x[1] x[2] x[3] x[4] x[5]

i=2 5 3 4 7 6
Compar 3 cu 5: 3¡5, deplasez 5 pe a doua poziţie, inserez 3 pe prima poziţie
i=3 3 5 4 7 6
Aşez 4 ı̂n poziţia finală: deplasez pe 5 o poziţie, ı̂n locul lui 5 inserez pe 4
i=4 3 4 5 7 6
Aşez 7 ı̂n poziţia finală: observ că rămâne pe locul lui, subşirul e deja ordonat
i=5 3 4 5 7 6
Aşez 6 ı̂n poziţia finală: deplasez pe 7 o poziţie, ı̂n locul lui 7 inserez pe 6
3 4 5 6 7

6
4 SelectSort
Ideea care stă la baza sortării prin selecţie este de a alege din şirul de sortat acel element
care va fi aşezat pe prima poziţie a vectorului (cel mai mic). Presupunând ca acest element
se află iniţial ı̂n vectorul de sortat pe poziţia k, va fi necesară o interschimbare ı̂ntre el
şi elementul de pe prima poziţie a vectorului. Se va aplica această regulă pentru restul
elementelor vectorului, ı̂ncepând cu al doilea, până vom obţine şirul sortat.

4.1 Implementarea pseudocode

Algoritmul 4 Selection Sort

1: procedure SelectionSort(A)
2: for i ← 0 to n − 1 do
3: minIndex ← i
4: for j ← i + 1 to n − 1 do
5: if A[j] < A[minIndex] then
6: minIndex ← j
7: swap(A[i], A[minIndex])

4.2 Complexitatea alogritmului

1. Timp mediu: O(n2 )
2. Timp la limită: O(n2 )
3. Memorie: O(1)
4. Stabil: DA
n(n−1)
5. Număr comparări: 2

4.3 Exemplu pe un vector

Fie tabloul X=(5,0,8,7,3)

Pas Vectorul Elementul minim Pozitita minimului Noul tablou

i=1 5,0,8,7,3 0 2 0,5,8,7,3
i=2 0,5,8,7,3 3 5 0,3,8,7,5
i=3 0,3,8,7,5 5 5 0,3,5,7,8
i=4 0,3,5,7,8 7 4

References
[1] Culegere Baicoianu Majercsik (MateInfo)
[2] Available from http://elf.cs.pub.ro/sda-ab/wiki/laboratoare/laborator-02
[3] ALGORITMI FUNDAMENTALI O PERSPECTIVĂ C++, De (autori): RĂZVAN
ANDONIE, ILIE GÂRBACEA ,Editura: Libris Cluj-Napoca, 1995
[4] Available from http://sortare.freewb.ro/metode-de-sortare