Download
curs 5 n.
Skip this Video
Loading SlideShow in 5 Seconds..
Curs 5 PowerPoint Presentation

Curs 5

215 Vues Download Presentation
Télécharger la présentation

Curs 5

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. Curs 5 • Sortare internă • sortare prin inserţie • sortare prin selecţie • naivă • sistematică (“heap sort”) • sortare prin interclasare (“merge sort”) • sortare rapidă (“quick sort”) • Căutare • în liste liniare • căutare binară – aspectul dinamic • arbori AVL 2008 - 2009

  2. Problema sortăriihttp://en.wikipedia.org/wiki/Sorting_algorithm • Forma 1 • Intrare: n, (v0, . . . , vn-1) • Ieşire: (w0, . . . , wn-1)astfel încât (w0, . . . , wn-1)este o permutare a (v0, . . . , vn-1), şi w0  . . .  wn-1 • Forma 2 • Intrare: n, (R0, . . . , Rn-1) cu cheile k0, . . . , kn-1 • Ieşire: (R’0, . . . , R’n-1)astfel încât (R’0, . . . , R’n-1)este o permutare a (R0, . . . , Rn-1 ), şi R’0.k0  . . .  R’n-1.kn-1 • structura de date Tabloua[0..n-1] a[0] = v0, . . . , a[n-1] = vn-1 2008 - 2009

  3. Sortare prin inserţie directă • Principiul de bază: presupunem a[0..i-1] sortat inserează a[i] astfel încât a[0..i] devine sortat • Algoritm (căutarea poziţiei lui a[i] secvenţial): procedure insertSort(a, n) begin for i  1 to n-1 do j  i – 1// a[0..i-1] sortat temp  a[i] // caut locul lui temp 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 2008 - 2009

  4. Sortare prin inserţie directă • Exemplu 3 7 2 1 3 7 2 1 2 3 7 1 1 2 3 7 • Analiza • căutarea poziţiei i în a[0..j-1] necesită O(j-1) paşi • cazul cel mai nefavorabil a[0] > a[1] > ... > a[n-1] Timp căutare: O(1+2+...+n-1) = O(n2) TinsertSort(n) = O(n2) • Cazul cel mai favorabil: O(n) 2008 - 2009

  5. Sortare prin selecţie • Se aplică următoarea schemă: • pasul curent: selectează un element şi-l duce pe poziţia sa finală din tabloul sortat • repetă pasul curent până când toate elementele ajung pe locurile finale • După modul de selectare a unui element: • Selecţie naivă:alegerea elementelor în ordinea în care se află iniţial (de la n-1 la 0 sau de la 0 la n-1) • Selecţie sistematică: utilizare max-heap 2008 - 2009

  6. Sortare prin selecţie naivă • în ordinea n-1, n-2,..., 1, 0, adică: (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 este O(n2) 2008 - 2009

  7. x a[i] y z 0 3 a[2*i+1] a[2*i+2] 1 2 9 8 3 4 5 6 1 7 12 4 8 7 2 5 “Heap sort”(sortare prin selecţie sistematică) • etapa I • organizează tabloul ca un max-heap ( (k) 1  k  n-1  a[k]  a[(k-1)/2] ) • iniţial tabloul satisface proprietatea max-heap incepând cu n/2 • introduce în max-heap elementele de pe poziţiile n/2-1, n/2 -2, …, 1, 0 2008 - 2009

  8. “Heap sort” (sortare prin selecţie sistematică) etapa II • selectează elementul maxim şi-l duce la locul lui prin interschimbare cu ultimul • micşorează cu 1 şi apoi reface max-heapul • repetă paşii de mai sus până când toate elementele ajung pe locul lor 12 9 8 1 7 3 4 2 5 2008 - 2009

  9. 9 7 8 1 5 3 4 2 “Heap sort”(sortare prin selecţie sistematică) 2008 - 2009

  10. Operaţia de introducere în heap 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 2008 - 2009

  11. “Heap sort”(sortare prin selectie sistematică) 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 2008 - 2009

  12. “Heap sort” - Exemplu 10 17 5 23 7 (n = 5) 10 175 23 7 1023 5 17 7 23 10 5 17 7 23 17 5 10 7 (max-heap n) 2008 - 2009

  13. “Heap sort” - Exemplu 23 17 5 10 7 (max-heap n) 7 17 5 10 23 17 10 5 7 23 (max-heap n-1) 7 10 5 17 23 10 7 5 17 23 (max-heap n-2) 5 7 10 17 23 7 5 10 17 23 (max-heap n-3) 5 7 10 17 23 5 7 10 17 23 (max-heap n-4) 5 7 10 17 23 2008 - 2009

  14. “Heap sort” - complexitate • formarea heap-ului (pp. ) • eliminare din heap si refacere heap • complexitate algoritm de sortare 2008 - 2009

  15. Paradigma divide-et-impera • P(n): problemă de dimensiune n • baza: • dacă n  n0 atunci rezolvă P prin metode elementare • divide-et-impera: • divide P în a probleme P1(n1), ..., Pa(na) cu ni  n/b, b > 1 • rezolvăP1(n1), ..., Pa(na) in aceeaşi manierăşi obţine soluţiile S1, ..., Sa • asambleazăS1, ..., Sa pentru a obţine soluţia S a problemei P 2008 - 2009

  16. 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 2008 - 2009

  17. 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: interclasează subsecvenţele sortate a[p..m]şia[m+1..q] • iniţial memorează rezultatul interclasării în temp • copie din temp[0..p+q-1] in a[p..q] • complexitate: • timp : T(n) = O(n log n) • spaţiu suplimentar: O(n) 2008 - 2009

  18. Interclasarea a două secvenţe sortate • problema: • date a[0]  a[1]  …  a[m-1], b[0]  b[1]  …  b[n-1], să se construiascăc[0]  c[1]  …  c[m+n-1] a.i. ( k)((i)c[k]=a[i])  (j)c[k]=b[j]) iar pentru k!=p, c[k] şi c[p] provin din elemente diferite • soluţia • iniţial: 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 • condiţia de terminare: i > m-1 sau j > n-1 • daca e cazul, copie elementele din tabloul neterminat 2008 - 2009

  19.  x  x x k q p Sortare rapidă (Quick sort) • generalizare: a[p..q] • baza: p  q • divide-et-impera • divide: determinăk între pşi q prin interschimbări a.î. după determinarea lui k avem: • p  i  k  a[i]  a[k] • k < j  q  a[k]  a[j] • subprobleme: a[p..k-1], a[k+1..q] • asamblare: nu există 2008 - 2009

  20. Quick sort: partiţionare • iniţial: • x  a[p] (se poate alege x arbitrar din a[p..q]) • i  p+1 ; j q • pasul curent: • dacăa[i]  xatunci i  i+1 • dacăa[j]  xatunci j  j-1 • dacăa[i] > x > a[j]si i < j atunci • swap(a[i], a[j]) • i  i+1 • j  j-1 • terminare: condiţiai > j operaţii k i-1 swap(a[p], a[k]) 2008 - 2009

  21. Quick sort: Exemplu 10 17 5 23 7 p = 0, q = 4 i = 1, j = 4 10 7 5 23 17 i = 2, j = 3 i = 3, j = 2 k = 2 5 7 10 23 17 5 7 10 17 23 2008 - 2009

  22. Căutare • în liste liniare • căutare binară – aspectul dinamic • arbori AVL 2008 - 2009

  23. Problema căutării • aspectul static U mulţime univers S  U • operaţia de căutare: Instanţă: a U Întrebare: a S? • aspectul dinamic • operaţia de inserare Intrare: x U, S Ieşire: S  {x} • operaţia de ştergere Intrare: x U, S Ieşire: S  {x} 2008 - 2009

  24. Căutare în liste liniare - complexitate 2008 - 2009

  25. Căutare binară – aspect static • mulţimea univers este total ordonata: (U, ) • structura de dată utilizată: • tablouls[0..n-1] • s[0]< ... < s[n-1] 2008 - 2009

  26. Cautare binară – 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 2008 - 2009

  27. m T(m+1,q) T(p,m-1) 2 0 4 1 3 5 Arborele binar asociat cautarii binare T(p,q) T = T(0,n-1) n = 6 2008 - 2009

  28. Cautare binară: aspect dinamic • arbore binar de căutare: arbore binar cu proprietatea căîn orice nod veste memorată o valoare dintr-o mulţime total ordonată şi are proprietăţile: • valorile memorate în subarborele din stânga lui vsunt mai mici decât valoarea din v • valoarea din veste mai mică decâtvalorile memorate în subarborele din dreapta lui v. 2008 - 2009

  29. Căutare binară: aspect dinamic - căutare function Poz(t, x) begin p  t while (p != NULL && p->val != x) do if (x < p->val) then p  p->stg else p  p->drp return p end 2008 - 2009

  30. Căutare binară: 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 adaugaxca fiu stinga al luipredp else adaugaxca fiu dreapta al lui predp end 2008 - 2009

  31. Cautare binară: aspect dinamic - eliminare • se cautăxîn arborele t; dacă-l găseşte se disting cazurile: • cazul 1: nodul p care memoreazăx nu are fii • cazul 2: nodul p care memoreazăx are un singur fiu • cazul 3: nodul p care memoreaza x are ambii fii • determină nodul q care memoreaza cea mai mare valoare y mai mica decât x (coboară din p la stânga şi apoi coboară la dreapta cât se poate) • interschimbă valorile din pşi q • şterge qca în cazul 1 sau 2 2008 - 2009

  32. Cautare binară: 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 inlocuiesteinpredppepcup->stg end 2008 - 2009

  33. Cautare binară: 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 2008 - 2009

  34. 20 elimina(10) elimina(50) elimina(0) 20 20 40 0 40 0 40 30 50 30 50 30 10 50 20 insereaza(32) insereaza(35) 20 20 40 40 40 30 30 30 35 35 32 Degenerarea căutării binare în căutare liniară 2008 - 2009

  35. Arbori AVL(Adelson-Velskii, Landis 1962) • un arbore binar de căutare t este un arbore AVL-echilibrat dacă pentru orice vârf v, h(vstg)  h(vdrp) 1 • Lema Dacă t este AVL-echilibrat cu n noduri interne atuncih(t)  (log n). 2008 - 2009

  36. Arbori AVL • Teoremă Clasa arborilor AVL-echilibraţi este O(log n) stabilă. • algoritmul de inserare/ştergere • nodurile au memorate şi factorii de echilibrare (1, 0, 1) • se memorează drumul de la radacină la nodul adăugat/ştersîntr-o stivă (O(log n)) • se parcurge drumul memorat în stivăîn sens invers şi se reechilibează nodurile dezichilibrate cu una dintre operaţiile: rotaţie stânga/dreapta simplă/dublă (O(log n)). 2008 - 2009

  37. y x y x A C B C A B z y x D z x y A A B C D B C Rotaţii Rotaţie dreapta simplă Rotaţie dreapta dublă 2008 - 2009