ALGORYTMY I STRUKTURY DANYCH

ALGORYTMY I STRUKTURY DANYCH WYKŁAD 04 k-ty co do wielkości. Stosy Grażyna Mirkowska PJWSTK, ITN semestr letni 2002

Plan wykładu • Wyszukiwanie 2-go co do wielkości elementu • Algorytm naiwny • Jak poprawić algorytm naiwny • Struktura danych - stos • k-ty co do wielkości • Algorytm Hoare • Rekursja czy stos? G. Mirkowska, ASD_04 k-ty co do wielkości

Drugi największy element Problem Dany jest ciąg e elementów e[1],...,e[n] pewnej przestrzeni liniowo uporządkowanej < E,  >. Znaleźć drugi co do wielkości element tego ciągu. WP = { e[i]  e[j] dla i  j , n>0}, WK = {1 wynik n, e[j]  e[wynik] < e[max] dla j=1,2,...,n } e[wynik] = maximum({e[1]...,e[n]} - maximum{e[1],...,e[n]}) Algorytm naiwny : 1. Znaleźć element maksymalny. 2. Usunąć go z rozważań . 3. Znaleźć element maksymalny w pozostałym zbiorze. G. Mirkowska, ASD_04 k-ty co do wielkości

Algorytm naiwny { i := 2; max :=1; while i  n do if e[i] > e[max] then max := i fi; i := i+1; od; pom := e[1]; e[1] := e[max]; e[max] := pom; i:=3; wynik := 2; while i n do if e[i] > e[wynik] then wynik := i fi; i := i+1; od;} Max := maximum(1,n); • Max: = 1;for ( i =2; i<= n; i++){ if (e[i]>e[max]){max:=i;}} Swap(e[1], e[max]); • wynik := 2;for ( i =3; i<= n; i++){ if (e[i]>e[wynik]){wynik:=i;}} Wynik := maximum(2,n); Koszt T(n) = 2n -3 G. Mirkowska, ASD_04 k-ty co do wielkości

4 2 3 5 7 8 1 6 Czy to można zrobić lepiej? Metoda polega na porównywaniu sąsiednich elementów ciągu. Elementy większe (wygrywające) przechodzą do następnej ‘rundy’. Metoda - Turniej 4 5 8 6 5 8 8 G. Mirkowska, ASD_04 k-ty co do wielkości

Analiza metody Każdy element, z wyjątkiem maksymalnego przegrał co najwyżej raz. Element drugi co do wielkości przegrał jedynie z elementem maksymalnym. Gdzie szukać elementu "drugiego" ? Wśród elementów, które grały z największym! Por. przykład G. Mirkowska, ASD_04 k-ty co do wielkości

Koszt algorytmu „Turniej” Załóżmy, że n= 2k. n -1 porównań Krok1. Zbudowanie drzewa turnieju. Krok 2. Wybranie elementu drugiego największego. lg n -1 Tyle, ile było ‘rund’! A ile elementów przegrało z największym? Razem : T(n)= n + lg n -2 G. Mirkowska, ASD_04 k-ty co do wielkości

Podstawowe struktury danych Algorytmy + struktury Danych = Programy e1, e2, e3, ..., en Lista STOS początek koniec Operacje na lewym końcu listy Operacje na listach Operacje na prawym końcu listy toppushpop rearinjecteject Pobranie elementu z listy.Wstawianie elementu na listę.Usuwanie elementu z listy. G. Mirkowska, ASD_04 k-ty co do wielkości

Stos i jego własności < S  E, push, pop, top, empty> s = (e1,e2,..., en) element3 push(s, e) = (e, e1,e2,..., en)pop(s) = (e2,..., en) o ile n>1top(s) = e1empty(s) wttw n=0 next ogniwo element2 next Własności top(push(s,e)) = epop(push(s,e))= snot empty(s) => push(pop(s),top(s))=sIstnieje i takie że empty(popi(s)) element1 next G. Mirkowska, ASD_04 k-ty co do wielkości

LISTA a next stosp w next stosp e’ e” Struktura danych dla algorytmu ‘Turniej’ Następnyelement głównej listy OGNIWO listy Lista elementów, które przegrały z e (kandydaci do drugiego miejsca) STOS G. Mirkowska, ASD_04 k-ty co do wielkości

e[i] e[i+1] e[i+2] e[i+3] ... i+3 k i l i+2 i+1 Algorytm ‘Turniej’ Tworzenie wyników pierwszej rundy for i := 1 to n div 2 do if e[i] < e[i+1] then L:=push(i,L); L.stosp := push(i+1, L.stosp); else L:= push(i+1, L); L.stosp := push(i, L.stosp); fi; od; Wkładam na stos element, który przegrał. ... L G. Mirkowska, ASD_04 k-ty co do wielkości

x y Budowa drzewa turnieju while not empty(L) do x := L; while not empty(x) do y := x.next; if e[x.w] > e[y.w] then x.stosp := push (x.stosp, y.w) else y.stosp := push(y.stosp, x.w); x.w := y.w; x.stosp := y.stosp fi; x.next := y.next; x := x.next odod; Dołącz y do elementów, które przegrały z x Dołącz x do elementów, które przegrały z y Rozważmy pierwszy element następnej pary G. Mirkowska, ASD_04 k-ty co do wielkości

III etap - przeszukiwanie stosu { Pom := L.stos; drugi := pom.w; pom :=pop(pom); while not empty(pom) do if e[drugi ] < e[top(pom)] then drugi := top(pom) fi; pom := pop(pom); od} G. Mirkowska, ASD_04 k-ty co do wielkości

Twierdzenie Algorytm Turniej jest optymalnym algorytmem pozwalającym znaleźć drugi co do wielkości element ciągu. G. Mirkowska, ASD_04 k-ty co do wielkości

K-ty największy Problem: Dany jest ciąg n-elementów pewnej przestrzeni liniowo uporządkowanej <E,  >. Znaleźć k-ty największy element tego ciągu.. Przykład 2, 4, 6, 12, 78, 45, 3, 33, 17, 22 Element największy = 78element drugi co do wielkości = 453-ci największy = 334-ty największy = 22 G. Mirkowska, ASD_04 k-ty co do wielkości

Pierwsze rozwiązanie Krok1. Wyszukaj element e[max] największy wśród elementów e[i],...,e[n]; Krok 2. Zamień elementy na pozycjach i-tej i max . Krok 3. Powtórz postępowanie dla następnego i. Koszt : T(n) = (n-1) + (n-2) +... +(n-k) =k*n - k*(k+1)/2 G. Mirkowska, ASD_04 k-ty co do wielkości

Algorytm naiwny Zakładam, że elementy w ciągu e nie powtarzają się. { x := 1; while x k do max := x; for i := x+1 to n do if e[i] > e[max] then max := i fi od; swap(e[x], e[max]); x := x+1; od; wynik := e[k]} Niezmiennik e[1]>...>e[x-1] >{e[x],...,e[n] } e[max] {e[x],...,e[n]} e[1]>...>e[x-1] >{e[x],...,e[n] } G. Mirkowska, ASD_04 k-ty co do wielkości

Czy można zrobić to taniej? M = mediana Rozdziel wszystkie elementy na większe od pewnego elementu M(część starsza) i na mniejsze od M (część młodsza). Umieść medianę tak by oddzielała cześć młodszą od starszej. Wynikiem jest mediana, jeśli w części starszej jest tylko k-1 elementów. W przeciwnym przypadku: jeśli elementów starszych jest >k-1, to szukaj k-tego elementu w części starszej. Jeśli elementów starszych jest mniej niż k-1, to szukaj elementu k-(liczba elementów starszych+1) wśród elementów młodszych. G. Mirkowska, ASD_04 k-ty co do wielkości

5 7 9 4 3 2 6 1 11 12 Część młodsza Część starsza 4 3 2 1 7 9 6 Część młodsza Część starsza Przykład W podanym ciągu szukamy 7tego co do wielkości elementu 10 5 7 9 11 4 3 2 12 8 6 1 mediana 10 5 7 9 4 3 2 6 1 Szukam 4-go największego mediana 5 Wynikiem jest element 5 G. Mirkowska, ASD_04 k-ty co do wielkości

Algorytm Hoare Zakładam, że elementy w ciągu nie powtarzają się i, że algorytm zwraca jako wynik wartość k-tego największego elementu. function Hoare(l, p, k){ j := SPLIT(l, p); if ( p-j = k-1) then wynik := e[j] else if p-j>k-1 then Hoare(j+1, p, k) else Hoare(l,j-1, k-(p-j+1)) fi fi} {e[1]...,e[j-1]}< e[j]<{e[j+1],...,e[n]} K-ty największy znajduje się wśród elementów e[j+1],... e[p] K-ty największy znajduje się wśród elementów e[l],... e[j-1] G. Mirkowska, ASD_04 k-ty co do wielkości

Algorytm rozdzielania int function SPLIT(l,p){ mediana := e[l]; i := l+1; j := p; while (j > i ) do while (e[j]> mediana ) do j := j-1 od; while (e[i] < mediana) do i := i+1 od; If (i<j) then swap(e[i], e[j]); i := i+1; j := j-1; fi od; swap(e[l],e[j]); return j; } (i, l< i <j) e[i] < e[j] (i, j < i  p) e[j]  e[i] G. Mirkowska, ASD_04 k-ty co do wielkości

i < j 10, 5, 9, 8, 3, 7, 12, 14, 11 mediana j i i > j 10, 5, 9, 8, 3, 7, 12, 14, 11 j i Jak to działa? 3 14 10, 5, 9, 8, 14, 7, 12, 3, 11 mediana i j 7 10 G. Mirkowska, ASD_04 k-ty co do wielkości

Koszt algorytmu Hoare Każdy element jest co najwyżej raz porównywany z medianą. Koszt algorytmu SPLIT Czyli T(SPLIT, n ) = n-1 = (n) Czyli W(n,k)= k*n – k(k+1)/2 W( n,k) = n-1 +W( n-1,k) A(n,k) = (n-1) + 1/n[ Sj=1...n-k A(n-j, k) + Sj=n-k+2... n A(j-1,k – (n-j+1)] Szukanie w części starszej Szukanie w części młodszej A(n,k) = O(n) G. Mirkowska, ASD_04 k-ty co do wielkości

ALGORYTMY I STRUKTURY DANYCH