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

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ówNotacja :

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

n0n

c2g(n)f(n)

c1g(n)

f(n)=(g(n))

n0n

cg(n)f(n)

f(n)=O(g(n))

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

1 2 3 4 5 6 7

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 57 1 8

head[Q] = 2

1 2 3 4 5 6 7

tail[Q] = 6

Struktury danych: listy

/ 5 6 4 /1head[L]

prev key next

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-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-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ęciAllocate-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]