Curs 5 - Agenda

 sortare interna
 “buble sort”
 sortare prin insertie
 sortare pri selectie
 naiva
 sistematica (“heap sort”)
 sortare prin interclasare (“merge sort”)
 sortare rapida (“quick sort”)
 cautare
 in liste liniare
 cautare binara – aspectul dinamic
 arbori AVL
Dorel Lucanu Algoritmica si programare
Problema sortarii
 Forma 1
 Intrare: n, (R0, . . . , Rn-1) cu cheile
k0, . . . , kn-1
 Iesire: (R’0, . . . , R’n-1) astfel incit
(R’0, . . . , R’n-1) este o permutare a
(R0, . . . , Rn-1 ) si R’0.k0  . . .  R’n-1.kn-1
 Forma 2
 Intrare: n, (v0, . . . , vn-1)
 Iesire: (w0, . . . , wn-1) astfel incit
(w0, . . . , wn-1) este o permutare a
(v0, . . . , vn-1), si w0  . . .  wn-1
 structura de date
array a[0..n-1]
a[0] = v0, . . . , a[n-1] = vn-1

Dorel Lucanu Algoritmica si programare

Bubble sort I
 idee:
(i) 0  i < n-1  a[i]  a[i+1]
 algoritm
procedure bubbleSort (a, n)
begin
ultim  n-1
while ultim > 0 do
ntemp  ultim – 1
ultim  0
for i  0 to ntemp do
if a[i] > a[i+1]
then swap(a[i], a[i+1])
ultim  i
end
Dorel Lucanu Algoritmica si programare
Bubble sort II

 exemplu
 analiza
 cazul cel mai nefavorabil
a[0] > a[1] > ... > a[n-1]
TbubleSort(n) = O(n2)

Dorel Lucanu Algoritmica si programare

 Sortare prin insertie directa I
 idee
presupunem a[0..i-1] sortat
insereaza a[i] astfel incit a[0..i] devine sortat
 algoritm
procedure insertSort(a, n)
begin
for i  1 to n-1 do
j  i – 1
temp  a[i]
while ((j  0) and (a[j] > temp)) do
a[j+1]  a[j]
j  j – 1
if (a[j+1]  temp) then a[j+1] 
temp
end
Dorel Lucanu Algoritmica si programare
Sortare prin insertie directa II

 exemplu
 analiza
 cazul cel mai nefavorabil
a[0] > a[1] > ... > a[n-1]
TinsertSort(n) = O(n2)

Dorel Lucanu Algoritmica si programare

Sortare prin selectie

 ideea de baza
 pasul curent: selecteaza un element si-l
duce pe pozitia sa finala din tabloul sortat
 repeta pasul curent pana cnd toate
elementele ajung pe locurile finale

Dorel Lucanu Algoritmica si programare

Sortare prin selectie naiva

 idee
(i ) 0  i < n  a[i] = max{a[0],…,a[i]}
 algoritm
procedure naivSort(a, n)
begin
for i  n-1 downto 0 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
 complexitatea timp toate cazurile:
TnaivSort(n) = Θ(n2)
Dorel Lucanu Algoritmica si programare
"Heap sort" (sortare prin selectie sistematica)

 etapa I
 organizeaza tabloul ca un max-heap
 initial tablou satisface proprietatea max-
heap incepand cu n/2
 introduce in max-heap elementele de pe
pozitiile n/2-1, n/2 -1, …, 1, 0
 etapa II
 selecteaza elementul maxim si-l duce la
locul lui prin interschimbare cu ultimul
 micsoreaza cu 1 si apoi reface max-heapul
 repeta pasii de mai sus pana cand toate
elementele ajung pe locul lor

Dorel Lucanu Algoritmica si programare

Operatia de introducere in heap al t-lea

procedure insereazaAlTlea(a, n, t)
begin
j  t
heap  false
while ((2*j+1 < n) and not heap) do
k  2*j+1
if ((k < n-1) and (a[k] < a[k+1]))
then k  k+1
if (a[j] < a[k])
then swap(a[j], a[k])
j  k
else heap  true
end
Dorel Lucanu Algoritmica si programare
"Heap sort" (sortare prin selectie sistematica)

procedure heapSort(a, n)
begin
// construieste maxheap-ul
for t  (n-1)/2 downto 0 do
insereazaAlTlea(a, n, t)
// elimina
r  n-1
while (r > 0) do
swap(a[0], a[r])
insereazaAlTlea(a, r, 0)
r  r-1
end
Dorel Lucanu Algoritmica si programare
"Heap sort" - complexitate

 formarea heap-ului (pp. n  2k  1 )

k 1

 2
i 0
( k  i  1) 2 i
 2 k 1
 2(k  1)

 eliminare din heap si refacere heap

k 1

 2i
i 0
2 i
 ( k  2) 2 k 1
4

 complexitate algoritm de sortare

TheapSort (n)  2n log n  2n  O(n log n)

Dorel Lucanu Algoritmica si programare

Timpul de executie empiric

 Intel Pentium III 1.00 Ghz

n bubbleSort insertSort naivSort heapSort

10 0.0000 0.0000 0.0000 0.0000
100 0.0000 0.0000 0.0000 0.0000
1000 0.0310 0.0000 0.0150 0.0000
2000 0.1100 0.0150 0.0320 0.0000
4000 0.4840 0.0630 0.0930 0.0160
8000 1.9530 0.2500 0.3590 0.0160
10000 3.0940 0.4060 0.5780 0.0160

Dorel Lucanu Algoritmica si programare

Paradigma divide-et-impera

 P(n): problema de dimensiune n

 baza
 daca n  n0 atunci rezolva P prin metode
elementare
 divide-et-impera
 divide P in a probleme P1(n1), ..., Pa(na) cu
ni  n/b, b > 1
 rezolva P1(n1), ..., Pa(na) in aceeasi maniera
si obtine solutiile S1, ..., Sa
 asambleaza S1, ..., Sa pentru a obtine
solutia S a problemei P

Dorel Lucanu Algoritmica si programare

Paradigma divide-et-impera: algoritm

procedure DivideEtImpera(P, n, S)
begin
if (n <= n0)
then determina S prin metode
elementare
else imparte P in P1, ..., Pa
DivideEtImpera(P1, n1, S1)
...
DivideEtImpera(Pa, na, Sa)
Asambleaza(S1, ..., Sa, S)
end

Dorel Lucanu Algoritmica si programare

Sortare prin interclasare (Merge sort)

 generalizare: a[p..q]
 baza: p  q
 divide-et-impera
 divide: m = [(p + q)/2]
 subprobleme: a[p..m], a[m+1..q]
 asamblare: interclaseaza subsecventele sortate
a[p..m] si a[m+1..q]
 initial memoreaza rezultatul interclasarii in
temp
 copie din temp[0..p+q-1] in a[p..q]
 complexitate:
 timp : T(n) = O(n log n) (T(n) = 2T(n/2)+n)
 spatiu suplimentar: O(n)
Dorel Lucanu Algoritmica si programare
Interclasarea a doua secvente sortate
 problema:
 date a[0]  a[1]  …  a[m-1],
b[0]  b[1]  …  b[n-1],
sa se construiasca c[0]  c[1]  …  c[m+n-1]
a.i. ( k)((i)c[k]=a[i])  (j)c[k]=b[j])
 solutia
 initial: i  0, j  0, k  0
 pasul curent:
 daca a[i]  b[j]
atunci c[k]  a[i], i  i+1
 daca a[i] > b[j]
atunci c[k]  b[j], j  j+1
 k  k+1
 conditia de terminare: i > m-1 sau j > n-1
 daca e cazul, copie elementele din tabloul neterminat
Dorel Lucanu Algoritmica si programare
Sortare rapida (Quick sort)

 generalizare: a[p..q]
 baza: p  q
 divide-et-impera
 divide: determina k intre p si q prin
interschimbari a.i. dupa determinarea lui k
avem:
 p  i  k  a[i]  a[k]
 k < j  q  a[k]  a[j]
 x x  x
p k q
subprobleme: a[p..k-1], a[k+1..q]
asamblare: nu exista

Dorel Lucanu Algoritmica si programare

Quick sort: partitionare

 initial:
 x  a[p] (se poate alege x arbitrar din
a[p..q])
 i  p+1 ; j  q
 pasul curent:
 daca a[i]  x atunci i  i+1
 daca a[j]  x atunci j  j-1
 daca a[i] > x > a[j] si i < j atunci
swap(a[i], a[j])
i  i+1
j  j-1
 terminare:
conditia i > j
operatii k  i-1
swap(a[p], a[k])
Dorel Lucanu Algoritmica si programare
Cautare

 in liste liniare
 cautare binara – aspectul dinamic
 arbori AVL

Dorel Lucanu Algoritmica si programare

Problema cautarii
 aspectul static
U multime univers
SU
 operatia de cautare:
Instanta: a  U
Intrebare: a  S?
 aspectul dinamic
 operatia de inserare
Intrare: x  U, S
Iesire: S  {x}
 operatia de stergere
Intrare: x  U, S
Iesire: S  {x}
Dorel Lucanu Algoritmica si programare
Cautare in liste liniare - complexitate

Tip de Implementare Cautare Inserare Stergere

date
Lista Tablouri O(n) O(1) O(n)
liniara
Liste inlantuite O(n) O(1) O(1)

Lista Tablouri O(log n) O(n) O(n)

liniara
ordonata
Liste inlantuite O(n) O(n) O(1)

Dorel Lucanu Algoritmica si programare

Cautare binara – aspect static - context

 multimea univers este total ordonata: (U, )

 structura de data utilizata:
 array s[0..n-1]
 s[0]< ... < s[n-1]

Dorel Lucanu Algoritmica si programare

Cautare binara – aspect static - algoritm
function Poz(s, n, a)
begin
p  0; q  n-1
m  [(p+q)/2]
while (s[m] != a && p < q) do
if (a < s[m])
then q  m-1
else p  m+1
m  [(p+q)/2]
if (s[m] = a)
then return m
else return -1;
end

Dorel Lucanu Algoritmica si programare

Arborele binar asociat cautarii binare
m
T(p,q)

T(p,m-1) T(m+1,q)

T = T(0,n-1)
2
n=6
0 4

1 3 5

Dorel Lucanu Algoritmica si programare

Cautare binara: aspect dinamic

 arbore binar de cautare

 arbore binar cu proprietatea ca pentru
orice nod v, valorile memorate in
subarborele la stinga lui v
<
valoarea din v
<
valorile memorate in subarborele la
dreapta lui v.

Dorel Lucanu Algoritmica si programare

Cautare binara: aspect dinamic - cautare

function Poz(t, a)
begin
p  t
while (p != NULL && p->val != a) do
if (a < p->val)
then p  p->stg
else p  p->drp
return p
end

Dorel Lucanu Algoritmica si programare

Cautare binara: aspect dinamic - inserare
procedure insArbBinCautare(t, x)
begin
if (t = NULL)
then t  (x) /*(x) e arborele cu 1 nod */
else p  t
while (p != NULL) do
predp  p
if (x < p->val) then p  p->stg
else if (x > p->val)then p  p->drp
else p  NULL
if (predp->val != x) then
if (x < predp->val)
then adauga x ca fiu stinga a lui predp
else adauga x ca fiu dreapta a lui predp
end
Dorel Lucanu Algoritmica si programare
Cautare binara: aspect dinamic - eliminare

 se cauta pentru x in arborele t; daca-l gaseste

se disting cazurile:
• cazul 1: nodul p care memoreaza x nu are fii
• cazul 2: nodul p care memoreaza x are un
singur fiu
• cazul 3: nodul p care memoreaza x are ambii
fii
– determina nodul q care memoreaza cea
mai mare valoare y mai mica decit x
(coboara din p la stinga si apoi coboara la
dreapta cit se poate)
– interschimba valorile din p si q
– sterge q ca in cazul 1 sau 2
Dorel Lucanu Algoritmica si programare
Cautare binara: aspect dinamic - eliminare

 cazul 1 sau 2
procedure elimCaz1sau2(t, predp, p)
begin
if (p = t)
then t devine vid sau unicul fiu al lui t devine
radacina
else if (p->stg = NULL)
then inlocuieste in predp pe p cu p->drp
else inlocuieste in predp pe p cu p->stg
end

Dorel Lucanu Algoritmica si programare

Cautare binara: aspect dinamic - eliminare
procedure elimArbBinCautare(t, x)
begin
if (t != NULL)
then p  t
while (p != NULL && p->val != x) do
predp  p
if (x < p->val) then p  p->stg
else p  p->drp
if (p != NULL)
if (p->stg = NULL || p->drp = NULL)
then elimCaz1sau2(t, predp, p)
else q  p->stg; predq  p
while (q->drp != NULL)
predq  q; q  q->drp
p->val  q->val
elimCaz1sau2(t, predq, q)
end
Dorel Lucanu Algoritmica si programare
Degenerarea cautarii binare in cautare liniara
elimina(10) 20 elimina(0) 20 elimina(50)
20

0 0 40 40
40

30 50 30 50
10 30 50

20
20 insereaza(35) 20 insereaza(32)

40
40 40
30
30 30
35
35

32
Dorel Lucanu Algoritmica si programare
Arbori AVL
 un arbore binar de cautare t este un arbore
AVL-echilibrat daca pentru orice virf v,
h(vstg)  h(vdrp) 1
 Lema
t AVL-echilibrat  h(t)  (log n).

Dorel Lucanu Algoritmica si programare

Arbori AVL

 Teorema
Clasa arborilor AVL-echilibrati este O(log n)
stabila.
 algoritmul de inserare
 nodurile au memorate si factorii de
echilibrare ( {1, 0, 1})
 se memoreaza drumul de la radacina la
nodul adaugat intr-o stiva (O(log n))
 se parcurge drumul memorat in stiva in
sens invers si se reechilibeaza nodurile
dezichilibrate cu una dintre operatiile:
rotatie stinga/dreapta simpla/dubla
(O(log n)).
Dorel Lucanu Algoritmica si programare
Rotatii
Rotatie dreapta simpla
y x
y
x
C A

A B B C

Rotatie dreapta dubla

z
y
x
D z
y x
A
A B C D
B C
Dorel Lucanu Algoritmica si programare