1 / 37

Curs 5

Curs 5. S ortare intern ă sortare prin inser ţ ie sortare pri n 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.

vail
Télécharger la présentation

Curs 5

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

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

More Related