Zaawansowane techniki algorytmiczne

Prezentacja na temat: "Zaawansowane techniki algorytmiczne"— Zapis prezentacji:

1 Zaawansowane techniki algorytmiczne
Analiza algorytmów. Struktury danych. Algorytmy grafowe. Operacje na macierzach. Kombinatoryka. Materiały pomocnicze znajdują się pod adresem:

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] 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] i:= i-1 7. A[i+1] := key Przykład działania algorytmu

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. return S[top[S]+1] 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. return x 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. 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 then next[prev[x]] := next[x] else head[L] := next[x] 4. if next[x]  NIL then prev[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. 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

12 Struktury danych: drzewa
Drzewa binarne root[T]

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