1 / 13

Zaawansowane techniki algorytmiczne

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.

azize
Télécharger la présentation

Zaawansowane techniki algorytmiczne

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. 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]

More Related