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

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.

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.

Czas działania algorytmów Algorytm sortowania Insertion-Sort(A) 1. for j:=2 to length[A] 2. do key:=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. do A[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 1 2 4 5 6 3 1 2 3 4 5 6

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)

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

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. return S[top[S]+1] 1 2 3 4 5 6 7 S 5 6 2 9 top[S] = 4 S[4] = 9

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. return x 1 2 3 4 5 6 7 Q 7 1 8 5 head[Q] = 2 tail[Q] = 6

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. then prev[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. do x := next[x] 4. return x List-Delete(L, x) 1. if prev[x]  NIL 2. then next[prev[x]] := next[x] 3. else head[L] := next[x] 4. if next[x]  NIL 5. then prev[next [x]] := prev[x]

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

Przydzielanie i zwalnianie pamięci Allocate-Object() 1. if free = 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

Struktury danych: drzewa Drzewa binarne root[T]

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