Zaawansowane techniki algorytmiczne

1. Zaawansowane techniki algorytmiczne Analiza algorytmów. Struktury danych. Algorytmy grafowe. Operacje na macierzach. Kombinatoryka. Materiały pomocnicze znajdują się pod adresem: http://www.pz.zgora.pl/iie/pomoce/index.html

2. Literatura podstawowa • Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest. Wprowadzenie do algorytmów. WNT, Warszawa, 1998. • Edward M. Reingold, Jurg Nievergelt, Narsingh Deo. Algorytmy kombinatoryczne. PWN, Warszawa, 1985. • Giovanni De Micheli. Synteza i optymalizacja układów cyfrowych. WNT, Warszawa, 1998. • Robert Sedgewick. Algorytmy w C++. RM, Warszawa, 1999. • Lech Banachowski, Antomi Kreczmar, Wojciech Rytter. Analiza algorytmów i struktur danych. WNT, Warszawa, 1989.

3. Plan zajęć • Struktury danych. Ewaluacja czasu działania algorytmu. Stosy, kolejki, listy, drzewa. • Sortowanie. Sortowanie przez wstawienie, sortowanie przez kopcowanie, sortowanie szybkie. Analiza algorytmów sortowania. • Algorytmy grafowe. Reprezentację grafów w pamięci. Przeszukiwanie. Sortowanie topologiczne. Minimalne drzewa rozpinające. Najkrótsze ścieżki. • Zaawansowane metody algorytmiczne. Programowanie dynamiczne. Algorytmy zachłanne. • Algorytmy równoległe. Rodzaje algorytmów równoległych, analiza. • NP-zupełność. Wielomianowy czas. NP-zupełność i redukowalność. Problemy NP-zupełne.

4. Czas działania algorytmów Algorytm sortowania Insertion-Sort(A) 1. for j:=2 to length[A] 2. dokey:=A[j] /* Wstaw A[j] w posortowany ciąg A[1..j-1].*/ 3. i:= j-1 4. while i>0 i A[i] > key 5. doA[i+1]:= A[i] 6. i:= i-1 7. A[i+1]:= key Przykład działania algorytmu 5 2 4 6 1 3 2 5 4 6 1 3 2 4 5 6 1 3 2 4 5 6 1 3 1 2 4 5 6 3 1 2 3 4 5 6

5. Czas działania algorytmów Czas działania algorytmu Insertion-Sort: Niech n=length[A]. Oceniamy najgorszy przypadek. Pętla zewnętrzna: n-1 razy. Pętla wewnętrzna: od 1 do n-1 razy, średnia - n/2. Czas: T(n)  ( n-1 ) ( a + nb/2) = n2b/2 + n(a-b/2) - a Liczy się tylko rząd wielkości funkcji: pesymistyczny czas działania Insretion-Sort - (n2)

6. Czas działania algorytmów Notacja : (g(n)) = {f(n): istnieją stałe c1, c2 i n0 takie, że 0  c1g(n)  f(n)  c2g(n) dla wszystkich n  n0}. Asymptotyczne ogranicza funkcję od góry oraz od dołu. Notacja O: O(g(n)) = {f(n): istnieją stałe c i n0 takie, że 0  f(n)  cg(n) dla wszystkich n  n0}. Asymptotyczne ogranicza funkcję od góry. cg(n) c2g(n) f(n) f(n) c1g(n) f(n)=O(g(n)) f(n)=(g(n)) n n n0 n0

7. Struktury danych: stosy • Stos: last in, first out (LIFO) Push(S, x) 1. top[S] := top[S]+1 2. S[top[S]] := x Pop(S) 1. if Stack-Empty(S) 2. then error „niedomiar” 3. else top[S] := top[S]+1 4. returnS[top[S]+1] 1 2 3 4 5 6 7 S 5 6 2 9 top[S] = 4 S[4] = 9

8. Struktury danych: kolejki • Kolejka: first in, first out (FIFO) Enqueue(Q, x) 1. Q[tail[Q]] := x 2. if tail[Q] = length[Q] 3. then tail[Q] := 1 4. else tail[Q] := tail[Q] + 1 Dequeue(Q) 1. x := Q[head[Q]] 2. if head[Q] = length[Q] 2. then head[Q] := 1 3. else head[Q] := head[Q] + 1 4. returnx 1 2 3 4 5 6 7 Q 7 1 8 5 head[Q] = 2 tail[Q] = 6

9. Struktury danych: listy key prev next head[L] / 5 6 4 1 / List-Insert(L, x) 1. next[x]:= head[L] 2. if head[L]  NIL 3. thenprev[head[L]]:=x 4. head[L] := x 5. prev[x] := NIL List-Search(L, k) 1. x := head[L] 2. while x NIL i key[x]  k 3. dox := next[x] 4. returnx List-Delete(L, x) 1. if prev[x]  NIL 2. thennext[prev[x]] := next[x] 3. else head[L] := next[x] 4. if next[x]  NIL 5. thenprev[next [x]] := prev[x]

10. Przydzielanie i zwalnianie pamięci head[L] free head[L] free

11. Przydzielanie i zwalnianie pamięci Allocate-Object() 1. iffree = NIL 2. then error „brak pamięci” 3. else x := free 4. free := next[x] 5. return x Free-Object() 1. next[x] :=free 2. free := x

12. Struktury danych: drzewa • Drzewa binarne root[T]

13. Struktury danych: drzewa • Drzewa ukorzenione o dowolnym stopniu rozgałęzień root[T]