databáze, sítě a techniky programování x33dsp · 2010. 10. 26. · pws-kent, massachusetts,...
Post on 07-Dec-2020
1 Views
Preview:
TRANSCRIPT
Databáze, sítě a techniky programováníX33DSP
PPPPřřřřednednednednášášášášejejejejííííccccíííí: : : : Ing. TomIng. TomIng. TomIng. Tomášášášáš VlVlVlVlčččček, CSc.ek, CSc.ek, CSc.ek, CSc. CviCviCviCviččččííííccccíííí:::: Mgr. Mgr. Mgr. Mgr. IngIngIngIng. . . . David David David David ŠŠŠŠteinerteinerteinerteiner
Doc. Ing. ZdenDoc. Ing. ZdenDoc. Ing. ZdenDoc. Ing. Zdeněěěěk Kouba, CSc.k Kouba, CSc.k Kouba, CSc.k Kouba, CSc. IngIngIngIng. . . . Miloslav RadakoviMiloslav RadakoviMiloslav RadakoviMiloslav Radakovičččč
IngIngIngIng. . . . LenkaLenkaLenkaLenka NovNovNovNováááákovkovkovkováááá, PhD., PhD., PhD., PhD.
1
Anotace:Náplní předmětu jsou některé techniky a metody používané ve výpočetních systémech zaměřených na biomedicínské inženýrství. Cílem je položit jednotný základ informačních technologií pro všechny studenty magisterského programu BMI a vybavit absolventy základními znalostmi v oblasti systematického přístupu k programování, správě operačních systémů a sítí i k tvorbě elementárních databázových aplikací.
Osnova přednášek
2
1. Základy teorie složitosti, polynomiální a nepolynomiální problémy, neřešitelné úlohy (21.9.)
2. Státní svátek (28.9.)3. Datové struktury, jejich implementace, rekurze (5.10.)4. Algoritmy řazení a vyhledávání, komprimační algoritmy (12.10).5. Grafové algoritmy (19.10.)6. Databáze - datový model, relační model (26.10.)7. Normální formy, dotazovací jazyk SQL (2.11.)8. Dotazovací jazyk SQL (9.11.)9. Transakce, distrib. databáze, replikace, synchronizace (16.11.)10. Poč. sítě a jejich struktury, adresování, směrování v sítích (23.11.)11. IP protokoly, porty, služby. Základy bezpečnosti v sítích. (30.11.)12. Operační systémy I (7.12.)13. Operační systémy II (14.12.)14. Datové sklady, správa dokumentů, verzování (21.12.)
Podmínky udělení zápočtu a složení zkoušky
3
Podmínky udělení zápočtu Max. 2 absence Maximální počet bodů ze cvičení je 25 (celkem 5 úloh), pro získání zápočtu
min. 13 Během testu, řešení semestrální úlohy a zkoušky bude kladen důraz na
zásadu samostatné práce.
Podmínky zkoušky Zkouška probíhá ústně Tři otázky (algoritmy/databáze/sítě-OS) Na každou otázku písemná příprava Každá otázka ohodnocena max. 25 body Pokud je odpověď na libovolnou z těchto tří otázek hodnocena méně než 10
body, celková známka je nedostatečně Výsledná známka je dána součtem bodového hodnocení cvičení a odpovědí
na otázky dle platné klasifikační stupnice.
Doporučená literatura
4
Wróblewski, Piotr: Algoritmy. Datové struktury a programovacítechniky. Computer Press 2004. ISBN: 80-251-0343-9
Knuth, D.E.: Umění programovat. 1.díl Základní algoritmy. Computer Press 2008. ISBN: 978-80-251-2025-5
Herout, Pavel: Učebnice Jazyka Java, Kopp, 2003. Tutoriál Java - http://java.sun.com/docs/books/tutorial/ Wirth, N.: Algorithm + Data Structures = Program. Prentice-
Hall, New Jersey, 1975 Louden, Kenneth, C.: Programming Languages. Principles
and Practice. PWS-Kent, Massachusetts, 1993 Pokorný J., Halaška I.: Databázové systémy. Praha, ČVUT,
1998 Další publikace o DBMS aktuálně doporučí přednášející
1 Složitost algoritmů
5
Definice algoritmuAlgoritmus můžeme definovat jako jednoznačně určenou posloupnost
konečného počtu elementárních kroků vedoucí k řešení daného problému, přičemž musí být splněny základní vlastnosti každého algoritmu:
Hromadnost a univerzálnost - algoritmus musí vést k řešení celétřídy úloh, vzájemně se lišících pouze vstupními údaji.
Determinovanost (jednoznačnost) - v každém kroku algoritmu musí být jednoznačně určeno, co je výsledkem tohoto kroku a jak máalgoritmus dále pokračovat. Pro stejná vstupní data vydá algoritmus vždy stejný výsledek.
Konečnost - algoritmus v konečné době skončí. Rezultativnost - algoritmus při zadání vstupních dat vždy vrátí
nějaký výsledek. Korektnost - výsledek vydaný algoritmem musí být správný. Opakovatelnost – při použití stejných vstupních údajů musí
algoritmus dospět vždy k témuž výsledku.
1 Složitost algoritmů
6
Ověřování správnosti algoritmu Algoritmus můžeme považovat za korektní, pokud není opomenuta
žádná z možností zpracování dat při průchodu algoritmem. Algoritmus je parciálně správný, právě když platí, že pokud skončí,
vydá správný výsledek. Algoritmus je konečný, když pro všechna přípustná data algoritmus
po konečném počtu kroků skončí.Věta o zastavení – Halting Theorem. Úloha o zastavení není
algoritmicky řešitelná - neexistuje algoritmus, který by pro libovolnéslovo w a libovolný algoritmus A rozhodl, zda se A při vstupu wzastaví, nebo ne.
Kvantitativní ukazatele kvality algoritmů operační složitost paměťová složitost (náročnost)
1 Složitost algoritmů
7
Příklad 1 - Sekvenční hledání1 boolean searchLinear(Value[] array, Value val)
2 boolean ret = false;
3 for (int i = 0; i < array.length; i++)
4 if (val == array[i])
5 ret = true;
6 break;
7
8
9 return ret;
10
Operační složitost – v nejhorším případě cyklus proběhne n-krát. Paměťová náročnost – proměnné.
1 Složitost algoritmů
8
Příklad 2 – binární hledání1 boolean binSearch(Value[] array, Value val)
2 boolean ret = false;
3 int l = 0; int r = array.length; int i;
4 while (!ret && r >= l)
5 i = (l + r) / 2;
6 if (val == array[i])
7 ret = true;
8 else
9 if (val > array[i])
10 l = i + 1;
11 else
12 r = i - 1;
13
14
15
16 return ret;
17
1 Složitost algoritmů
9
Příklad 2 – binární hledání1 boolean binSearch(Value[] array, Value val)
2 boolean ret = false;
3 int l = 0; int r = array.length; int i;
4 while (!ret && r >= l)
5 i = (l + r) / 2;
6 if (val == array[i])
7 ret = true;
8 else
9 if (val > array[i])
10 l = i + 1;
11 else
12 r = i - 1;
13
14
15
16 return ret;
17
Operační složitost – v nejhorším případě cyklus proběhne log2(n) krát.
Paměťová náročnost – proměnné l, i a r .
1 Složitost algoritmů
10
Fibonacciho posloupnost
Příklad 3 – Rekurzivní výpočet Fibonacciho čísla
1 private int fib(int n)
2 return (n == 0)?0 : ((n == 1)?1 : fib(n-1) + fib(n-2));
3
n 0 1 2 3 4 5 6 7 8 9 10 11
f(n) 1 1 2 3 5 8 13 21 34 55 89 144
1 Složitost algoritmů
11
Fibonacciho posloupnost
n 0 1 2 3 4 5 6 7 8 9 10 11
f(n) 1 1 2 3 5 8 13 21 34 55 89 144
1 Složitost algoritmů
12
Příklad 3 – tisk posloupnosti
S rekurzí:1 public void printFib1(int n)
2 for (int i = 1; i <= n; i++)
3 System.out.println(i + " " + fib(i));
4
5
Neefektivní, viz strom volání fib() pro n=4
1 Složitost algoritmů
13
Bez rekurze:1 public void prinFib2(int n)
2 int p0 = 1; int p1 = 1; int p;
3 for (int i = 1; i <= n; i++)
4 System.out.println(i + " " + p0);
5 p = p1; p1 = p0 + p1; p0 = p;
6
7
I 1 2 3 4
p0 1 1 2 3 5
p1 1 2 3 5 8
p 1 2 3 5
f(i) 1 1 2 3 5
1 Složitost algoritmů
14
Složitost algoritmuSložitost závisí na velikosti vstupních dat, tj. můžeme
popsat jako funkci T(n), kde číslo n udává velikost vstupních dat. Např. T(n) = an + b je zápis lineární časové složitosti.
Multiplikativní konstanta a reprezentuje počet operací na jednotku vstupních dat, aditivní konstanta b udává nárůst složitosti nezávislý na velikosti vstupních dat.
Pro odhad složitosti důležitý pouze typ funkčnízávislosti.
Efektivní algoritmy - takové postupy, jejichž složitost je maximálně polynomiální (např. n2), nikoliv exponenciálnínapř. 2n).
1 Složitost algoritmů
15
1 Složitost algoritmů
16
Čas potřebný ke zpracování dat velikosti n, jestliže výpočetní složitost je dána funkcí T(n) a provedení jedné operace trvá 1 µs
T(n) 20 40 60 80 100
n 20 µs 40 µs 60 µs 80 µs 0,1 ms
n log (n) 86 µs 0,2 ms 0,35 ms 0,5 ms 0,7 ms
n2 0,4 ms 1,6 ms 3,6 ms 6,4 ms 10 ms
n3 8 ms 64 ms 0,22 s 0,5 s 1 s
n4 0,16 s 2,56 s 13 s 41 s 100 s
2n 1 s 11,7 dne 36600 let 3,6.109 let
n! 77000 let
1 Složitost algoritmů
17
Horní odhad složitosti algoritmu Tworst(n) udávásložitost algoritmu v nejhorším případě:
Složitost algoritmu f(n) je asymptoticky menší nebo rovna g(n), tj. f(n) = O(g(n)),
právě když existuje taková kladná konstanta c tak, že pro každou velikost dat n od určité hodnoty n0 platí: 0 ≤ f(n) ≤ cg(n), neboli:
Např.:2n2 + 3n + 4 = O(n2), neboť pro n0 = 1 a c = 10 platí
2n2 + 3n + 4 <= 10*n2.
1 Složitost algoritmů
18
Dolní odhad složitosti Tbest(n) určuje minimálnísložitost daného algoritmu, která nastává jen pro určité případy vstupních dat:
Složitost algoritmu f(n) je asymptoticky větší nebo rovna g(n), tj. f(n) = Ω(g(n)),
právě když existuje taková kladná konstanta c tak, že pro každou velikost dat n od určité hodnoty n0 platí: 0
≤ cg(n) ≤ f(n), neboli:
Např. zápis Tbest(n) = Ω (n3) udává kubickou dolnísložitost algoritmu.
1 Složitost algoritmů
19
Složitost v průměrném případě (očekávaná složitost)Tavrg(n) se počítá jako střední hodnota náhodné složitosti T(n) při nějakém rozložení vstupních dat. Někdy může být i řádově lepší než složitost v nejhorším případě.
Algoritmus je optimální pro danou úlohu, jestliže neexistuje algoritmus, který by úlohu řešil v nejhorším případě s menším počtem základních operací.
Asymptoticky stejná složitost – složitosti f(n), g(n) jsou asymptoticky stejné, právě když existují takové kladnékonstanty c1,c2 tak, že pro každou velikost dat n od určitéhodnoty n0 platí: 0 ≤ c1g(n) ≤ f(n) ≤ c2g(n), neboli:
1 Složitost algoritmů
20
Optimalizační úloha slouží k popisu úkolu nalezenířešení, které je omezeno podmínkami a kterézároveň nejlépe vyhovuje daným kritériím (účelovénebo kriteriální funkci)
Rozhodovací úloha je úloha, jejímž řešením je odpověď „ano“ nebo „ne“. Každá optimalizační úlohalze převést na rozhodovací úlohu.
Příklad - problém obchodního cestujícího.
1 Složitost algoritmů
21
Je dána množina měst M1,…, Mn a pro každou dvojici měst Mi, Mj je dána jejich přímá vzdálenost d(Mi, Mj). Uvažujme trasu, která je posloupnost měst M
π(1), Mπ(2), …, Mπ(n), kde π je permutace čísel 1,…,
n. Délka této trasy je
Optimalizační verze: Najděte trasu nejkratší délky. Rozhodovací verze: Je dáno navíc číslo K.
Rozhodněte, zda existuje trasa délky ≤ K. Řešení – NPC úloha, heuristické algoritmy
),(),()1()()1(
1
1
)( ππ+π
−
=
π+∑ MMdMMd
ni
n
i
i
1 Složitost algoritmů
22
Nedeterministický algoritmus má dvě fáze nedeterministická, kdy se náhodně vygeneruje řetězec
symbolů s
deterministická, kdy na vstupu úlohy je jak instance úlohy, tak řetězec s. Po konečném počtu kroků je výstupem„ano“ nebo „ne“.
Řetězec s je vlastně navržené řešení úlohy, které se v deterministické části otestuje, zda platí. Pro obchodního cestujícího je to číslo K.
Nedeterministický algoritmus je nedeterministický polynomiální (NP algoritmus), jestliže ověřující fáze je splnitelná v polynomiálním čase vzhledem k rozsahu vstupních dat.
1 Složitost algoritmů
23
Třída P je třída všech rozhodovacích úloh U, pro něž existujepolynomiální algoritmus, řešící U.
NP úloha je taková úloha, kdy platí : pro každou „ano“ instanci lzev polynomiálním čase ověřit správnost odpovědi „ano“. Pro „ne“instanci takový algoritmus neexistuje.
Třída NP je třída všech rozhodovacíchúloh U, pro něž existujenedeterministický algoritmus, pracující v polynomiálním čase.
1 Složitost algoritmů
24
Obtížnost rozhodovacích úloh se dá srovnávat. Pojem „U se redukuje na V“ zpřesňuje sdělení, že rozhodovacíúloha U není těžší než rozhodovací úloha V.
U se redukuje na V, jestliže existuje algoritmus A, který pro každou instanci I úlohy U zkonstruuje instanci A(I)
úlohy V tak, že I je „ano“ instance U iff A(I) je „ano“instance V.
Je-li A polynomiální, jde o polynomiální redukci. Rozhodovací úloha U je NP úplná, jestliže je NP úloha a každá NP úloha se na U polynomiálně redukuje. Třídu NP úplných úloh označujeme jako NPC. (NP úplné úlohy jsou nejtěžší mezi NP úlohami)
2 Datové struktury
25
Pole Seznam Zásobník Fronty FIFO Haldy a prioritní fronty Stromy Hash tabulky Slovníky
2 Datové struktury
26
Pole Datová struktura – kolekce elementů (hodnot či proměnných),
identifikovaných jedním nebo více indexy, ze kterých je adresa každého elementu spočitatelná; počet indexů koresponduje s dimenzí pole (vektor, matice, tensor)
předem stanovená velikost, prvky stejné velikosti přímý přístup na prvek pomocí indexu v konstatním čase vyhledání a zrušení prvku: O(n) - nutné projít (posunout) celé pole přidání/zrušení prvku na začátku a konci: O(1) nalezení nejmenšího a největšího prvku: O(n)
Setříděné pole vyhledání prvku v O(log n) smazaní prvku v O(log n), pokud je implementováno jako
označení prvku za neplatný (jinak v O(n) ) přidání prvku v O(n) nalezení nejmenšího v O(1) a největšího prvku v O(n)
2 Datové struktury
27
Spojový seznam lineární spojový seznam - dynamická datová struktura,
obsahující 1+ datových položek stejného typu, které jsou navzájem lineárně provázany vzájemnýmí odkazy pomocíukazatelů nebo referencí. Aby byl seznam lineární, nesmíexistovat cykly ve vzájemných odkazech.
jednosměrný seznam - každá položka odkazuje na položku následující, v obousměrném seznamu odkazuje položka na následující i předcházející položky; konec (tail) a začátek (head) seznamu označují zarážky
kruhový (cyklický) seznam – obsahuje cyklus, vytvořený navázáním konce a začátku seznamu
Sekvenční přístup k prvkům vyhledání prvku: O(n) přidání/zrušení prvku: O(1)
2 Datové struktury
28
Zásobník Abstraktní datový typ, charakterizován způsobem
manipulace s daty – LIFO (Last In, First Out) pro manipulaci se udržuje tzv. ukazatel zásobníku, který
udává tzv. vrchol zásobníku (poslední přidaná položka), a (minimálně) dvě operace – push a pop
Typická časová složitost O(1) operacíse snadno realizuje pomocí pole nebo lineárního (jednosměrného) spojového seznamu
Typické užití zásobníku pro ukládání infoa dat při volání zanořených procedur (bezpečnostní problém s buffer overflow)
2 Datové struktury
29
Fronty FIFO abstraktní datový typ, charakterizován způsobem
manipulace s daty- FIFO (First In, First Out). Typická časová složitost O(1) operací, realizuje se
obvykle pomocí spojového seznamu Obvyklé operace:
bool empty() – příznak prázdná/neprázdná fronta
T& front() – vrací referenci na položku v čele neprázdné fronty
void dequeue() – odebere položku v čele neprázdné fronty void enqueue(const T& foo) – zařadí argument foo na konec
fronty
int size() – vrací počet položek ve frontě
2 Datové struktury
30
Halda stromová datová struktura splňující vlastnost haldy:
pokud je B potomek A, pak klíč(A) ≥ klíč(B). min-heap - v kořenu stromu je prvek s nejmenším klíčem,
naopak max-heap.
2 Datové struktury
31
Halda min-heap - v kořenu stromu je prvek s nejmenším klíčem,
naopak max-heap. stromová datová struktura splňující vlastnost haldy:
pokud je B potomek A, pak klíč(A) ≥ klíč(B). Obvyklé operace:
delete-max / delete-min: odstranění kořene z max-/min-heapu
increase-key, decrease-key: aktualizace klíče v max-/min-heapu
insert: vložení nového klíče merge: spojení dvou heapů do jednoho nového
implementace v poli: ki < k2i+1, ki < k2i+2
2 Datové struktury
32
Prioritní fronty abstraktní datový typ, charakterizován způsobem
manipulace s daty: InsertWithPriority – vlož prvek s asociovanou prioritou
GetNext: vyber prvek s nejvyšší prioritou
PeekAtNext: ukaž prvek s nejvyšší prioritou, aniž by byl z fronty odstraněn
Implementace pomocí lineární struktury (pole, spojový seznam) – výběr z čela fronty O(1), vložení se zařazením O(n)
Implementace pomocí binárního stromu(haldy) – max-heap, výběr O(log n), vložení O(log n)
2 Datové struktury
33
Stromy zákl.pojmy - kořen stromu, (vnitřní) uzly či vrcholy, listy, předek (předchůdce)
a následovník, rodič a potomek, podstrom
stupeň (arita) uzlu = počet přímých následovníků vnitřního uzlustupeň stromu = maximální stupeň mezi všemi uzly stromu
cesta ve stromu:délka cesty = počet hran od kořene k danému uzlu (=hloubka uzlu)délka vnitřní cesty = součet délek cest jednotlivých uzlůprůměrná délka vnitřní cesty:
kde ni je počet vrcholů na i-té úrovni
hloubka uzlu - délka cesty od kořene k uzlu
hloubka stromu / výška stromu - rovna hodnotě maximální hloubky uzlu(pro binární strom: n=2h+1–1, tedy hloubka h=floor(log2n) )
∑=
i
inIinP .1
2 Datové struktury
34
Procházení stromem do šířky – procházení po hladinách (vrstvách úrovní) -
prohledávání do šířky. do hloubky – procházení od kořene stromu na potomky daného
vrcholu po jednotlivých větvích - prohledávání do hloubky.
Uspořádání – metody procházení: Přímé (pre-order) uspořádání - R, A, B Vnitřní (in-order) uspořádání - A, R, B Inverzní (post-order) uspořádání - A, B, R
Dokonale vyvážený strom – pro každý vrchol platí, že počet vrcholů v levém podstromu a pravém podstromu se lišínanejvýše o jedna.
Vyhledávací - všechny klíče v levém podstromu jsou menšínež a všechny klíče v pravém podstromu jsou větší než klíč v daném vrcholu.
A B
R
2 Datové struktury
35
Binární strom Orientovaný graf s jedním kořenem, z něhož existuje cesta do
všech vrcholů grafu; každý vrchol má max. dva následovníky a s výjimkou kořene právě jednoho předka. Kořen předka nemá.
Reprezentace - pomocí dynamické struktury (hrany reprezentovány ukazateli), pomocí pole (viz halda).
B-strom vícecestný m-ární strom, se stránkovou organizací; každá stránka
(až na jednu) musí obsahovat n až 2n uzlů, kde n je zvolenákonstanta (= řád B-stromu)
B-strom je díky této vlastnosti vyvážený, operace přidání, vyjmutí i vyhledávání tedy probíhají v logaritmickém čase (výška B-stromu min. logm n, max logm/2 n).
Typické užití – modifikace (B+) používají souborové systémy (NTFS, ReiserFS, XFS a JFS2) a relační databáze – ukládáníindexů
2 Datové struktury
36
seznam binární strom (min-) heap
insert O(1) O(log n) O(log n)
findMin O(n) O(1) O(1)
deleteMin O(n) O(log n) O(log n)
decreaseKey O(1) O(log n) O(log n)
delete O(n) O(log n) O(log n)
merge O(1) O(m log(n+m)) O(m log(n+m))
2 Datové struktury
37
Skip List Přeskakovací seznam - N-vrstvá struktura, popsána 1990 (William Pugh)
jako jednodušší/rychlejší alternativa k vyváženým stromům
Randomizovaná varianta setříděného spojového seznamu s dodatečnými paralelními vrstvami. Paralelní seznamy přeskakují více položek.
Vyhledávání začíná na nejvyšší vrstvě a přechází do nižších vrstev pokud je aktuální položka větší/rovna vyhledávanému klíči. Je-li rovna, je nalezeno, je-li aktuální položka větší, procedura se opakuje po návratu o jeden krok a přechodu do nižší vrstvy..
Operace Insert, Search, Delete jsou prováděny v čase O(log n) za podmínky dostatečného počtu vrstev
2 Datové struktury
38
Hash (rozptylovací) tabulky Datová struktura, která používá
hashovací funkci H(key) pro efektivní mapování klíče k na celé číslo z intervalu <0, N-1> a ukládá položky (klíč, data) na vypočtené pozice H(key)
Při mapování hašovací funkcí může docházet ke kolizím –řešení řetězené seznamy (rozptýlené tabulky), řetězenéseznamy s oblastí přetečení, otevřená adresace (sekundárníhashovací fce – lineární/kvadratické pokusy, double hash fce)
Perfektní hashování: ke kolizím nedochází Vlastnosti: nejhorší případ - všechny klíče kolidují – složitost
O(n) Při faktoru naplnění A = n/N (počet položek/velikost tab.) ≈ 0,7
je očekávaná složitost O(1) Příklad H(key) = Ordinal(key) mod N
2 Datové struktury
39
Řešení kolizí 1. řetězené seznamy
tzv. rozptýlené tabulky.
2. oblast přetečení řetězený seznam je vytvářen v oblasti přetečení
3. sekundární hashovací funkce - umístění vkládaného prvku na jinou volnou pozici,
kterou určíme sekundární hašovací funkcí. metoda lineárních pokusů - sekvenčně prohledává tabulku, G(i)=i ; tj.
h0 = H(k)hi = (h0 + i) mod L, i = 1,…, L-1
Prvky se shlukují kolem pozic primárních klíčů metoda kvadratických pokusů - rozptyluje prvky rovnoměrněji po celém poli, G(i)=ci2, tj.
h0 = H(k)hi = (h0 + ci2) mod L, i > 0, c>0
metoda dvojího hashováníh0 = H(k)hi = (h0 + j H’(k)) mod L, i > 0, c>0
L ... Neexistuje společný dělitel L a počet řádků (L je bezpečné), jinak se některé pozice obsazují a jiné vůbec
2 Datové struktury
40
Slovníky Slovník je abstraktní datová struktura, skládající se z
množiny unikátních klíčů a a množiny hodnot, kde každý klíč je asociován (mapován) s jednou hodnotou nebo s množinou hodnot.
Základní operace: new, insert, find and delete. new() vrací slovník D find(k, D) vrací hodnotu asociovanou s klíčem k ve slovníku D
insert(k, v, D) asociuje ve slovníku D klíč k s hodnotou v
delete(k, D) ruší klíč k ve slovníku D
Implementace – binární vyhledávací stromy (AVL), skip-listy, hash tabulky aj.
2 Datové struktury
41
Rekurze rekurzivní algoritmus volá sám sebe dokud není dosažena ukončovací podmínka Iterativní algoritmus používá opakující se konstrukce (cykly) Příklad
Tree (length, angle)Draw(length, angle);Tree(length/2, angle+delta);Tree(length/2, angle-delta);
Každý algoritmus využívající rekurzi lze přepsat do nerekurzivního tvaru (např. s použitím zásobníku)
Rekurzivní datové struktury – definice dynamických datových struktur (seznamy, stromy):struct node int n; // some data struct node *ptr_next; // pointer to another struct node
; // LIST is simply a synonym for struct node * typedef struct node *LIST;
3 Algoritmy řazení
42
Specifikace problému řazení (třídění):
A ... neprázdná množina prvků
Posl(A) ... množina všech posloupností prvků z A<a1,...an> ... prvky množiny Posl(A)
|q| ... délka posloupnosti Posl(A), přičemž Delka(<>) = 0 a Delka(<a1,..an>) = n
Klic(ai) ... klíč prvku ai pro porovnávání prvkůPosloupnost q je seřazená právě tehdy, když:
1. |q| < 2, nebo
2. |q| >=2 a současně platí:a)Klic (a1) <= Klic (a2) a
b)posloupnost <a2,...>, která vznikne z posloupnosti q vypuštěním prvku a1 je rovněž seřazená.
3 Algoritmy řazení
43
Klasifikace metod řazení
Dle způsobu uložení:
vnitřní řazení (řazení v paměti)
vnější řazení (řazení souborů)
Dle způsobu využití klíčů:
adresní řazení (Klic(x) udává polohu x ve výstupu)
asociativní řazení (Klic() využíván pro stanovení relativní polohy prvku ve výstupu, tj. je-li Klic(x) < Klic(y), pak ve výstupu x předchází y)
Algoritmus se nazývá stabilní, pokud se relativní pořadíprvků se shodným klíčem v procesu řazení nemění.
Algoritmus se nazývá přirozený, pokud algoritmus rychleji zpracuje seřazenou množinu než neseřazenou.
3 Algoritmy řazení
44
Algoritmy vnitřního řazení – základní metody
Řazení výběrem – nalezne vždy nejmenší z (zbývajících neseřazených) prvků a umístí na konec postupně budovanéposloupnosti.
Řazení vkládáním – v řazené posloupnosti prvků se postupně berou jednotlivé prvky a vkládají se na správné místo v budované seřazenéposloupnosti.
Řazení záměnou – algoritmy vyberou dvojici prvků, které jsou ve špatném pořadí, a tyto prvky navzájem zamění.
Řazení slučováním - vstupní posloupnost prvků rozdělí na části, které seřadí; seřazené části se poté sloučí tak, aby výslednáposloupnost byla seřazená.
Neexistuje „ideální“ algoritmus pro všechna možná data, algoritmy majírůzné časové a paměťové složitosti, implementační úskalí aj.
3 Algoritmy řazení
45
NázevČasová složitost Dodatečná
paměťStabilní Přirozená Metoda
Minimum Průměrně Maximum
Bubble sortBublinkové řazení
O(n) O(n²) O(n²) O(1) ano ano Záměna
HeapsortŘazení haldou
O(n log n) O(n log n) O(n log n) O(1) ne ne Výběr
Insertion sortŘazení vkládáním
O(n) O(n²) O(n²) O(1) ano ano Vkládání
Merge sortŘazení slučováním
O(n log n) O(n log n) O(n log n) O(n) ano ano Slučování
QuicksortRychlé řazení
O(n log n) O(n log n) O(n²) O(log n) ne ne Záměna
Selection sortŘazení výběrem
O(n²) O(n²) O(n²) O(1) ano/ne ne Výběr
Shell sort **Shellovo řazení
O(n3/2)O(n log² n)
O(1) ne ano Vkládání
Vlastnosti běžných algoritmů vnitřního řazení *
* Zdroj www.wikipedia.org** Složitost závisí na parametrech algoritmu (velikosti kroku), viz Robert Sedgewick: Analysis of Shellsort and Related Algorithms
3 Algoritmy řazení
46
Insertion Sort
for i ϵϵϵϵ < 2, n > „vlož ai na patřičné místo mezi a1, . . . , ai ”
void insertionSort(int[] arr)
int i, j, newValue;
for (i = 2; i < arr.length; i++)
newValue = arr[i];
j = i;
while (j > 0 && arr[j - 1] > newValue)
arr[j] = arr[j - 1];
j--;
arr[j] = newValue;
Autor Nuno Nogueira, wikipedia.org
Časová složitost O(n2), nejlepší O(n)Paměťová náročnost O(1)Stabilní algortimus
3 Algoritmy řazení
1 2 3 4 5 6 7 8
44 55 12 42 94 18 06 67
i=2 44 55 12 42 94 18 06 67
i=3 12 44 55 42 94 18 06 67
i=4 12 42 44 55 94 18 06 67
i=5 12 42 44 55 94 18 06 67
i=6 12 18 42 44 55 94 06 67
i=7 06 12 18 42 44 55 94 67
i=8 06 12 18 42 44 55 67 94
47
Animace: http://www.sorting-algorithms.com/insertion-sort
3 Algoritmy řazení
48
1. Je-li seznam délky 0 nebo 1, je seřazen. Jinak:2. Rozděl seznam na dva cca poloviční velikosti. 3. Seřaď každý vzniklý seznam rekurzivně. 4. Spoj dva seznamy zpět do seřazeného seznamu. Merge sort je založen na myšlence:1. Krátký seznam se řadí menším počtem kroků
než delší seznam. 2. K vytvoření seřazeného seznamu je méně kroků
potřeba při spojení dvou seřazených seznamůnež neseřazených.
Animace: http://www.sorting-algorithms.com/merge-sort
Nevýhoda - potřeba dočasného pole velikosti N. Mergesort bývá pomalejší než Quicksort nebo Heapsort. Výhoda - stabilní řadicí algoritmus, dobře se paralelizuje. Implementován standardně v Perlu, v Javě, GNU C Library).
Časová složitost O(n log n)Paměťová náročnost O(n) (dočasné pole)
Merge Sort
3 Algoritmy řazení
49
1. V poli zvolíme libovolný prvek x; 2. Hledáme zleva, dokud se nenajde prvek ai > x; 3. Hledáme zprava, dokud se nenajde prvek aj < x. 4. Tyto dva prvky zaměníme5. Pokračujeme, dokud se hledání zleva a zprava nesetkají u prvku x. 6. Výsledkem jsou dva úseky: v levém jsou všechny prvky < x a v pravém > x.7. Rekurzivně seřadíme levý i pravý úsek.
• Problém - volba pivota, při volbě mediánu je algoritmus velmi rychlý, v opačném případěse časová složitost blíží O(n2). Hledání mediánu běží v lineárním čase k počtu prvků, tím je výsledná složitost O(n log2n) v nejhorším případě. Není stabilní.
Medián je hodnota, jež dělí řadu podle velikosti seřazených výsledků na dvě stejně početné poloviny.
Animace: http://www.sorting-algorithms.com/quick-sort
1 2 3 4 5 6 7 844 55 12 42 94 18 06 67
06 55 12 42 94 18 44 67
06 18 12 42 94 55 44 67
• Na náhodných datech je nejrychlejší
• Paměťovánáročnost O(log n) dána rekurzivními voláními
Quick Sort
3 Algoritmy řazení
50
Heap SortVyužití datové struktury halda (heap), s indexací od 1:Halda je posloupnost klíčů hl, hl+1, ..., hn takových, že platí pro všechna i = l ... n/2:hi < h2i , hi < h2i+1 [min-heap], resp. hi > h2i , hi > h2i+1 [max-heap]
Přidávání do haldy:
1. Přidej prvek do spodní úrovně haldy na první místo zleva.2. Porovnej přidaný prvek s rodičem. Jsou-li ve správném pořadí, konec.3. Prohoď přidaný prvek s rodičem a jdi na předchozí bod.
11
5 8
3 4 15
11
5
83 4
15 115
83 4
15
Postup přidávání prvků pro max-heap
3 Algoritmy řazení
51
Heap SortVyužití datové struktury halda (heap), s indexací od 1:Halda je posloupnost klíčů hl, hl+1, ..., hn takových, že platí pro všechna i = l ... n/2:hi < h2i , hi < h2i+1 [min-heap], resp. hi > h2i , hi > h2i+1 [max-heap]
Odebírání kořenového prvku z haldy:1. Nahraď kořen posledním prvkem poslední úrovně.2. Porovnej nově umístěný prvek s potomky. Jsou-li ve správném pořadí, konec.3. Prohoď nově umístěný prvek s potomkem a jdi na předchozí bod.
115
83 4
15
115
83 4
115
3 4
8 11
5
3 4
8
Postup odebírání kořene pro max-heap
3 Algoritmy řazení
52
Heap SortVyužití datové struktury halda (heap), s indexací od 1:Halda je posloupnost klíčů hl, hl+1, ..., hn takových, že platí pro všechna i = l ... n/2:hi < h2i , hi < h2i+1 [min-heap], resp. hi > h2i , hi > h2i+1 [max-heap]
Základní princip algoritmu heap sort:
1. Vybudujeme haldu postupným zařazováním prvků z nesetříděného pole s využitímalgortimu vkládání prvku do haldy.
2. Postupně odebíráme kořenové prvky z haldy (s využitím algoritmu pro odebírání kořene)a vkládáme je do výsledného pole.
3. V případě max-heap je výsledné pole setříděno sestupně, v případě min-heap je setříděno vzestupně.
h1
h3
h6
h12 h13
h7
h14 h15
h2
h4
h8 h9
h5
h10 h11
3 Algoritmy řazení
53
Heap SortVyužití datové struktury halda (heap), s indexací od 1:Halda je posloupnost klíčů hl, hl+1, ..., hn takových, že platí pro všechna i = l ... n/2:hi < h2i , hi < h2i+1 [min-heap], resp. hi > h2i , hi > h2i+1 [max-heap]
• Je dáno pole h1 ... hn , prvky hn/2+1 ... hn již tvoříhaldu - tvoří listy příslušného binárníhostromu a nevyžadují přeuspořádání.
• Ke stávající haldě budemepřidávat další prvky "zleva"- haldu rozšíříme v každémkroku o 1 prvek doleva, ažvytvoříme n-prvkovou haldu
• třídění „na místě„ - zaměníme prvek z kořene haldy a poslední prvek haldy hn
• Přeuspořádáme haldu h1 ... hn-1
• Postup se opakuje pro stále se zmenšující haldu. Při každém kroku je na vrcholu haldy největší ze zbývajících prvků, a ten je výměnou s posledním prvkem této menší haldy zařazen na správné pořadí v poli.
Časová složitost O(n log n), paměťová náročnost O(1), není stabilní
3 Algoritmy řazení
54
06 67 94 18
18 0642
67
94
06
18 1255
67
94
06
18 12
42
55
67
94
06
12
18 44
42
55
67
94
I
II
III
IV
V
atd. ...
1 2 3 4 5 6 7 8
I 44 55 12 42 94 18 06 67
II 44 55 12 42 94 18 06 67
III 44 55 06 42 94 18 12 67
IV 44 42 06 55 94 18 12 67
V 06 42 12 55 94 18 44 67
67 42 12 55 94 18 44 06
12 42 67 55 94 18 44 06
12 42 18 55 94 67 44 06
12 42 18 55 94 67 44 06
44 42 18 55 94 67 12 06
3 Algoritmy řazení
55
Řazení v souborech – přímé a přirozené slučování (Merge Tape Sort)• soubor se jako celek nevejde do operační paměti• sekvenční struktury, je přístupný právě jeden element každého otevřeného souboru.• operace přesouvání jsou časově náročné
44 55 12 42 94 18 06 67 44 55 12 42
94 18 06 67
44 94 18 55 06 12 42 67 44 94 18 55
06 12 42 67
06 12 44 94 18 42 55 67 06 12 44 94
18 42 55 67
06 12 18 42 44 55 67 94
rozdělení
sloučení do usp. dvojic
sloučení do usp. čtveřic
rozdělení
sloučení do usp. osmic
rozdělení
• Na přímé slučování nemá žádný vliv částečné setřídění vstupní posloupnosti a délka všech uspořádaných sloučených posloupností po k-tém kroku je ≤ 2k
• Přirozené slučování slučuje vždy dvě nejdelší možné uspořádané posloupnosti – max.běhy
3 Algoritmy řazení
56
Tvorba setříděného souboru:•kmenový soubor - setříděný rozsáhlý•změnový soubor - malý, možno setřídit rychle, někdy i v poli v pamětiCílový setříděný soubor vznikne pouhým slučováním.
c
a
b
c
a
b
c
a
b
fáze
rozdělovací
fáze
slučovací
krok
c
a
b
c
d
c
a
b
2-fázové (tzv. třípáskové) třídění:
Modifikace - 1-fázové (tzv. čtyřpáskové) třídění:
- v rámci slučovacího procesu se uspořádané n-tice rovnou distribuují na dvě pásky
3 Algoritmy vyhledávání
57
Dokonale vyvážený strom je strom, pro jehož každý vrchol platí, že počet vrcholů v levém podstromu a pravém podstromu se lišínanejvýše o jedna.Tvorba dokonale vyváženého binárního stromu o n vrcholech:
zvolíme jeden vrchol za kořen
vytvoříme levý podstrom s počtem vrcholů nl = n div 2
vytvoříme pravý podstrom s počtem vrcholů nr = n - nl - 1
Pravidla aplikujeme rekurzivně
Binární vyhledávací strom je uspořádaný binární strom, ve kterém jsou všechny klíče v levém podstromu menší než a všechny klíče v pravém podstromu jsou větší než klíč daného vrcholu. Přetvoření existujícího dokonale vyváženého stromu na vyhledávací je však
velmi nákladné. Vyžaduje prakticky úplné přeuspořádání stromu. Podmínku na dokonalé vyvážení stromu lze oslabit, pak můžeme stromy budovat jižpřímo jako vyhledávací. To vede na úlohu vyhledávání spojeného s přidáváním, výsledný strom je však značně nevyvážený.
3 Algoritmy vyhledávání
58
Rušení vrcholů ve stromu
Inverzním problémem k přidávání je rušení vrcholů. Odstraňování prvku ze stromu je mnohem složitější než jeho přidání. V binárním stromu jsou možnéčtyři případy:
prvek s daným klíčem se ve stromu nenachází
prvek je listem - zrušení je triviální
prvek má jednoho následníka - prvek se nahradí svým následníkem
prvek má dva následníky - prvek se nahradí buďnejpravějším prvkem levého podstromu nebo nejlevějším prvkem pravého podstromu. V levém podstromu jsou všechny uzly s klíčem menším a v pravém s klíčem větším než klíčrušeného prvku
3 Algoritmy vyhledávání
59
AVL-vyvážené stromy Přidávání a rušení prvků stromu způsobuje
nevyvážení, dokonalé vyvážení stromu je velmi obtížné. Proto se hledaly alternativní definice vyváženosti, které by poskytovaly dostatečně efektivní vyhedávací možnosti, a byly přitom zvládnutelné. Adelson-Velskii a Landis [1962] publikovali následující kriterium vyváženosti:
Binární strom je AVL-vyvážený právě tehdy, když výšky obou podstromů každého uzlu se liší nejvýše o jedna,
každý podstrom je AVL vyvážený.
Autoři dokázali, že na vyvážených stromech mají operace vyhledání prvku podle klíče a přidání či vyjmutí prvku s daným
klíčem asymptotickou složitost O(log n), kde n je počet vrcholůve stromu.
3 Algoritmy vyhledávání
60
Pro reorganizaci zavádíme transformace (rotace), které modifikují strukturu stromu, avšak zachovávají lexikografické (in-order) uspořádání:
3 Algoritmy vyhledávání
61
Přidání vrcholu se pak skládá ze tří kroků:
Prohledání stromu za účelem zjištění, zda se takový vrchol již ve stromu nenachází.
Přidání vrcholu a určení vyvažovacího faktoru.
Kontrola vyvažovacího faktoru ve vrcholech ve směru opačném vůči vyhledávání (směrem ke kořenu) a případné vyvážení.
Operace rušení vrcholuje variací na rušenív obyčejném binárním stromu,doplněné o vyvažování
3
62
3 Algoritmy vyhledávání
63
B-stromy [BAYER 1970]: B-strom řádu n tedy splňuje následující kriteria:
Každá stránka obsahuje nejvýše 2n položek (=klíčů).
Každá stránka s výjimkou kořene stromu obsahuje aspoň n položek.
Každá stránka je buď listem stromu (a pak nemá následníky) nebo máprávě m+1 následníků, kde m je skutečný počet položek ve stránce.
Všechny listové stránky jsou na jedné úrovni.
V nejlepším případě je výška B-stromu logMn, v nejhorším případě logM/2n,
kde M je maximální počet potomků minimalizace přístupů (diskových operací) - rozsáhlé stromy, je možno rozdělit na stránky uložené na disku.
Aplikace: indexace tabulek v DBMS (DB2, MS SQL, Oracle, MySQL,...), indexace metadat v souborových systémech (NTFS, IBM JFS, ...) – B+ stromy
3 Algoritmy vyhledávání
64
1. Vyhledání prvku s klíčem k.
Načtení stránky do paměti. Vyhledání ve stránce (sekvenčně, binárním půlením).
Pokud se klíč ve stránce nenachází a stránka není list, hledáme ve stránce c1 , pokud key < k1,
ve stránce cm , pokud key > k(m − 1), m je aktuální počet prvků ve stránce
ve stránce ci , kde ki < k < ki + 1.
2. Přidání
Najdeme místo i pro vložení nového prvku s klíčem k, tak aby ki−1 < k < ki+1.
Pokud je ve stránce volné místo jednoduše vložíme nový prvek.
Pokud je stránka plná, je nutné přeuspořádání: Rozdělíme stránku (2n + 1 prvků)
na dvě podstránky stránky po nprvcích, „prostřední“ prvek zůstáváv rodičovské stránce.
Pokud přeteče kořen stromu, výška stromu se zvětší.
3 Algoritmy vyhledávání
65
Odebírání prvků z B-stromu
Pokud se odebíraný prvek nenachází v listové stránce, musí se nahradit jedním ze dvou lexikograficky sousedících prvků v listové stránce.
sestoupíme ve směru pravého ukazatele až do nejlevější listové stránky P,
nahradíme odebíraný prvek nejlevějším prvkem stránky P a snížíme velikost obsazení P (v podstatě hledáme nejmenší větší klíč, resp. následovníka z uspořádané posloupnosti klíčů). Alternativně lze sestupovat ve směru levého ukazatele k nejpravějšímu prvku.
Kontrola počtu prvků m ve stránce P: je-li m < n, je nutné provést reorganizaci - obsazenísousedních stránek P a Q se vyrovnává = vyvažování.
V případě, že stránka Q již dosáhla své minimální velikosti n, pak celkový počet prvků na stránkách P a Q je 2n-1 a stránky můžeme sloučit: do stránky P přesuneme "prostřední" prvek stránky předchůdců P a Q
do stránky P přesuneme prvky ze stránky Q a
stránku Q zrušíme.
Postup může vyvolat dalšívyvažování či slučování stránek na vyšší úrovni, v extrémním případěaž po kořen B-stromu. Když se velikost kořenové stránky zmenší na nulu, je třeba ji odstranit (jediný způsob zmenšení výšky B-stromu).
3 Algoritmy vyhledávání
66
B+ stromy Jsou modifikací B-stromů tak, že klíče jsou zopakovány v následnících a
listové stránky jsou navzájem propojeny obousměrnými spojkami:
B+ stromy se používajív moderních databázích jako forma indexních souborů. Při klasickém vyhledávání se postupuje prakticky stejně jako u obyčejných B-stromů. Ukazatele (diskové adresy dat) se nacházejí jen v listech.
B+ stromy jsou velmi výhodné z hlediska vytváření uspořáda-ných pohledůna data. Stačí procházet listy stromu a tím získávat data setříděná podle konkrétního klíče.
Z důvodů optimalizace přístupovédoby korespondují stránky s diskovými bloky.
Nevýhodou je opakování klíčůa složitější údržba stromů.
3 Komprimace dat
67
Členění: bezeztrátová komprimace – v procesu komprimace/dekomprimace
jsou originální data přesně obnovena ztrátová komprimace – v procesu komprimace/dekomprimace může
dojít k odchylkám od originálních dat Claude E. Shannon: A Mathematical Theory of Communication
(1948) – formulace teorie komprimace dat, definoval fundamentální limit pro bezeztrátovou kompresi – míru entropie H, která závisí na povaze informačního zdroje.
Není možné bez ztráty informace komprimovat data v poměru vyšším než je míra entropie.Teorie datové komprese vymezuje základníhranice účinnosti všech komprimačních algoritmů. Pro daný zdroj se známou statistickoupovahou a danou míru „zkreslení“ D, je možnénalézt tzv. rate-distortion function R(D),udávající pro přípustnou míru zkreslení nejlepšídosažitelný kompresní poměr R(D).
3 Komprimace dat
68
Zdroj má entropii H a dokonalý přenosový kanál kapacitu C; průměrná rychlost přenosu nemůže být větší než H/C.
Důsledek – nelze zkomprimovat informační zdroj pod velikost jeho entropie. Entropii H Shannon definoval pro stochasticképrocesy takto (počet bitů na znak):
kde m je velikost vstupní abecedy a pi jepravděpodobnost výskytu znaku i
Důležité vlastnosti pro komprimaci:1. H = 0 pouze v případě, že existuje jediné i takové, že pi > 0
uniformní zpráva mající všechny znaky stejné, bude mít entropii jdoucí k nule(můžeme ji zakódovat do jediného znaku).
2. Pro daný počet jevů n je H maximální, jestliže všechny jevy mají stejnou
pravděpodobnost p = 1/n. V takovém případě je H rovno log n.
náhodně generovaná zpráva s rovnoměrným rozložením má entropii rovnou jejívelikosti v bitech děleno počtem symbolů (maximální entropie).
3 Komprimace dat
69
Modely Informační zdroj X=X1,X2,..., angl.text, velikost
abecedy m=27 Zero-Order Model: znaky statisticky nezávislé,
pravděpodobnost výskytu jednotlivých znaků je shodná. Potom
H = log2m, tj. H = log2 27 = 4.75 [bitů/znak] First-Order Model: znaky statisticky nezávislé, pi je
pravděpodobnost výskytu i-tého znaku abecedy. Potom
, tj. pro angl.text 4.07 bitů/znak.
3 Komprimace dat
70
Second-Order Model: Nechť Pj|i je podmíněnápravděpodobnost, že aktuální symbol je j-tý znak abecedy, jestliže předchozí symbol je i-tý znak. Potom
, tj. 3.36 bitů/znak pro angl.text
Third-Order Model: Nechť Pk|j,i je podmíněnápravděpodobnost, že aktuální symbol je k-tý znak abecedy, jestliže předchozí symbol je j-tý znak abecedy, kterému předchází i-tý znak. Potom
, tj. 2.77 bitů/znak pro angl.text
Model lze zobecnit. Shannon odhadl, že entropie angl.textu je 2.3 bitů/znak.
71
Statistical Distributions of English Text (EXAMPLES)
I. First-Order Statistics
| a | b | c | d | e | f | g | h | i | j | k |
|=========|=========|=========|=========|=========|=========|=========|=========|=========|=========|=========|
0.0651738 0.0124248 0.0217339 0.0349835 0.1041442 0.0197881 0.0158610 0.0492888 0.0558094 0.0009033 0.0050529
II. Second-Order Statistics
The second number in the first row is the conditional probability P(Xi=b|Xi-1=a)=0.0228302
|| a | b | c | d | e | f | g | h | i | j |
||=========|=========|=========|=========|=========|=========|=========|=========|=========|=========|
a ||0.0002835 0.0228302 0.0369041 0.0426290 0.0012216 0.0075739 0.0171385 0.0014659 0.0372661 0.0002353
b ||0.0580027 0.0058699 0.0000791 0.0022625 0.3416714 0.0002057 0.0004272 0.0003639 0.0479084 0.0076894
c ||0.1229841 0.0000271 0.0215451 0.0005246 0.1715916 0.0000090 0.0000000 0.1701716 0.0565490 0.0000000
III. Third-Order Statistics
The fourth number in the second row is the conditional probability P(Xi=d|Xi-1=b,Xi-2=a)=0.0085877
|| a | b | c | d | e | f | g | h | i | j |
||=========|=========|=========|=========|=========|=========|=========|=========|=========|=========|
a a ||0.0000000 0.0000000 0.0106383 0.3297872 0.0000000 0.0106383 0.0000000 0.0000000 0.0000000 0.0000000
a b ||0.0075307 0.0140045 0.0000000 0.0085877 0.0202140 0.0000000 0.0000000 0.0029066 0.1762452 0.0014533
a c ||0.0066204 0.0000817 0.0963629 0.0006539 0.2368615 0.0000000 0.0000000 0.1985288 0.0402942 0.0000000
a d ||0.0304960 0.0001415 0.0000708 0.0352367 0.1144131 0.0038916 0.0004245 0.0027595 0.0417463 0.0038916
a e ||0.0345679 0.0000000 0.0024691 0.0098765 0.0074074 0.0000000 0.0222222 0.0000000 0.0000000 0.0000000
72
RLE (Run Length Encoding) Jednoduchý bezeztrátový komprimační algoritmus, kompresní poměr silně
závislý na charakteru dat – pokud neobsahovují delší sekvence stejných znaků, účinost komprese výrazně klesá. RLE nahrazuje sekvence stejných hodnot dvojicí (délka sekvence, hodnota).
Předpokládejme např. řetězec dat (17 bytů):ABBBBBBBBBCDEEEEF
Pomocí RLE komprese lze zkomprimovat např. takto: (10 bytů) :A *8B C D *4E F
Opakující se znaky jsou nahrazeny řídícím znakem a dvojicí (délka,znak).Existující různé modifikace.
Aplikace pro kompresi obrazových dat, který obsahuje větší plochy stejnébarvy. V grafických formátech existují různé varianty RLE komprese, buďjako hlavní komprese dat (např. PCX) nebo jako pomocná metoda komprese dat (JPEG, TIFF).
Typické užití pro TIFF CCITT fax formát.
3 Komprimace dat
73
Huffmanovo kódování
bezeztrátová komprese dat, konvertuje znaky vstupníabecedy do bitových řetězců – frekventované znaky do bitových řetězců s kratší délkou
Dvě fáze: 1. určení frekvence výskytu znaků, 2. vytvořeníbinárního stromu k následné komprimaci vstupních dat.
Jsou-li znaky např. E,T,A,S,N,O, uspořádány v binárním stromu:PotomTEA 10 00 010SEA 011 00 010TEN 10 00 110
3 Komprimace dat
74
Příklad konstrukce stromu:
3 Komprimace dat
75
Časová složitost Huffmanova algoritmu je O(n log2n).
DECAFD: 111E:1101C:100A: 0F:1100 111110110001100
111110110001100111: D1101: E100: C0: A1100: F DECAF
Příklad: komprimace
Příklad: dekomprimace
3 Komprimace dat
76
LZ77, LZ78 a LZW algoritmus (Abraham Lempel, Jakob Zivand Terry Welch)
LZ77. Publikovaný Abrehamem Lempelem a Jacobem Zivem v roce 1977. patří mezi takzvané slovníkové algoritmy
Algoritmus prochází data postupně od začátku do konce. V případě, že narazí na skupinu znaků, která se již v předchozích datech objevila, nahradí tuto skupinu znakůodkazem na předchozí výskyt. Komprimovaná data se pak skládají ze znaků, pro které nebyla nalezena žádná reference, tzv. literálů a referencí nahrazujících skupiny znaků.
Mějme text: the quick brown fox jumps over the lazy dog.
Slovo 'the' se vyskytuje dvakrát, lze komprimovat: the quick brown fox jumps over << lazy dog.
kde << je pointer na první čtyři znaky v textu.
3 Komprimace dat
77
Popis algoritmu LZ77: Při komprimaci se vytváří okno, které prochází přes sekvenci komprimovaných dat a v každém kroku hledá nejdelší část okna shodnou s předchozí sekvencí. Opakující se části dat odkazem na jejich původní výskyt, dvojicí (délka,offset) a připojí prvním následujícím znakem za ukazatelem.
Poz 1 2 3 4 5 6 7 8 9
A A B C B B A B C
Krok Aktuálnípozice
Shoda okna se sekvencí
Následujícíznak
Výstup
1. 1 - A (0,0)A
2. 2 A B (1,1)B
3. 4 - C (0,0)C
6. 7 AB C (2,2)C
Při dekomprimaci v každém kroku se čte ze vstupu pár (délka,ofset)Znak ze vstupu a na výstup jde sekvence daná oknem (délka,ofset) a Znak.
3 Komprimace dat
78
LZ78. Zatímco LZ77 pracuje na „minulých“ datech, LZ78 se pokouší pracovat s „budoucími“ daty. Prochází data a porovnává je se slovníkem, který udržuje. Dívá se dopředu v sekvenci a hledá co nejdelší sekvenci, nacházející se již ve slovníku. Na tu se pak odkazuje stejně jako v LZ77. Do slovníku je přidána sekvence společně s následujícím znakem, čímž slovník roste.
Mějme opět text: the quick brown fox jumps over the lazy dog.
Slovo 'the' se vyskytuje dvakrát, je tedy přidáno do slovníku a nahraženo odkazem *:
* quick brown fox jumps over * lazy dog.
3 Komprimace dat
79
LZW. Jde o modifikaci původního algoritmu, kterou vytvořil Terry Welch (1984). LZW pracuje, podobně jako LZ78, na principu udržování slovníku a odkazováním do něj. Na rozdíl od LZ78 si LZW slovník postupně vytváří spojováním kratších slov. Na počátku je slovník inicializován jednoznakovými slovy použité abecedy (typicky 256 znaků ASCII). Postupně, jak prochází sekvenci, ukládá do slovníku nalezené unikátní dvoupísmenné výrazy a jednopísmennéslovo vypíše na výstup. Tímto způsobem postupně skládá slova dohromady a rozšiřuje si tak slovník.
set w := NILloop
read a character k if wk exists in the dictionary
w := wk else
output the code for w add wk to the dictionary w := k
endloop
read a character k output k w := k loop
read a character k entry := dictionary entry for k output entry add w + first char of entry to the dictionary w := entry
endloop
Animace: http://www.cs.sfu.ca/CC/365/li/squeeze/LZW.html
3 Vyhledávání v řetězcích
80
Nechť P je řetězec velikosti m, pak•fragment P[i..j] se sestává z i-tého až j-tého znaku řetězce P
•prefixem (předponou) řetězce P je fragment typu P[0..i]
•sufixem (příponou) řetězce P je fragment typu P[i..m-1]
Mějme řetězce T (text) a P (vzorek), pak úloha spočívá ve vyhledávánífragmentu P v řetězci T
Typické algoritmy pro vyhledávání výskytů jednoho vzorku
Brute-force Match - algoritmus „hrubé síly“ Knuth-Morris-Prattův algoritmus porovnává vzorek s textem zleva doprava,
ale posouvá vzorek inteligentněji než brute-force algoritmus Algoritmus Boyer-Moore – algoritmus porovnává vzorek s textem od konce
vzorku, tj. zprava doleva, při neshodě přeskakuje znaky
Vyhledávání výskytů množiny vzorkůAlgoritmus Aho-Corasickové - algoritmus je založen na vyhledávání ve slovníku
uspořádaném do tzv. keyword tree struktury (tzv. trie) s využitím konečného stavového automatu
3 Vyhledávání v řetězcích
81
Brute-force MatchAlgoritmus „hrubé síly“ porovnává
vzorek P délky m s řetězcem T
délky n pro každé možné posunutíP vůči T, dokud
je nalezena shoda, nebo všechna umístění vzorku byla
vyzkoušena
Časová složitost je O(nm)
Příklad pro nejhorší případ:
T = „aaa … ah“, P = „aaah“
Může se vyskytnout v binárních datech (např. v obrázcích), pro text je nepravděpodobné.
Algorithm BruteForceMatch(T, P)Input text T of size n, pattern P of size mOutput starting index of asubstring of T equal to P or −1 if no such substring existsfor i ← 0 to n − m test shift i of the pattern
j ← 0while j < m and T[i + j] = P[j]
j ← j + 1endwhileif j = m thenreturn i match at i
endforreturn -1 no match anywhere
0 1 2 3 4 5 6 7 8 9
p a t t e r n m a
0 1 2 3
t e r n
i j
T P
3 Vyhledávání v řetězcích
82
Algoritmus Boyer-Moore
Algoritmus se opírá o dvě heuristiky:
„Zrcadlová“ heuristika: Porovnej sekvenci v T se vzorkem P od konce, tj. zprava doleva
Přeskakování znaků: Když nastane neshoda ve znaku T[i] = c
Pokud P obsahuje c, posuň P tak, aby se shodoval poslední výskyt c vP s T[i] , viz případ A; není-li posun doprava možný (poslední výskyt c je za aktuální pozicí), pak posuneme P doprava o jeden znak
Pokud neobsahuje, posuň P tak, aby P[0] souhlasilo s T[i + 1], viz případ B
T[i]=“t”
“t”≠”m”
T[i]=“a”
“a”≠”m”
P[0]
T[i+1]T=“a pattern matching algorithm”
P=“rithm”
A B
Příklad:
3 Vyhledávání v řetězcích
83
Boyer-Moorův algoritmus předzpracovává vzorek P a abecedu Σ tak, aby sestavil funkci „posledního výskytu (last-occurrence)“ L mapující Σ na celáčísla, kde L(c) je definováno jakonejvětší index i takový, kdy P[i] = c, nebo−1, pokud takový neexistuje
Příklad: P = “abacab”, Σ = a, b, c, d
Funkce posledního výskytu L(c) může být reprezentována polem indexovaným podle numerického kódu znaku; funkce se napočítá pro vzorek P před vyhledávánímČasová složitost funkce L(c) je úměrná O(m + s), kde m je velikost P a s je velikost abecedy ΣAlgoritmus je vhodný pro vyhledávání v textových řetězcích
0 1 2 3 4 5
a b a c a b
c a b c d
L(c) 4 5 3 -1
3 Vyhledávání v řetězcích
84
Algorithm BoyerMooreMatch(T, P, Σ)L(c) ... lastOccurenceFunction(P, Σ )i ← m − 1j ← m − 1repeat
if T[i] = P[j]if j = 0
return i match at i else
i ← i − 1j ← j − 1
else character-jump l ← L[T[i]]i ← i + m – min(j, 1 + l)j ← m − 1
until i > n − 1return −1 no match
index posledního znaku v příznaku P
Porovnej sekvenci v T s příznakem P od konce, tj. zprava doleva
Když nastane neshoda, posuň P vůči T
Pozn.: m...počet znaků v P, n...počet znaků v T
pole P a T indexovány od nuly
posl
ednívý
skyt
v P
zanesh
odo
u
poslední výskyt v P
před neshodou
3 Vyhledávání v řetězcích
85
Příklad:
Časová složitost Boyer-Moorova algoritmu je O(nm + s) Příklad pro nejhorší případ:
T = „aaa … a“, P = „baaa“Může se vyskytnout v binárních datech (např. v obrázcích), pro text je nepravděpodobné.
Boyer-Moorův algoritmus je na textu výrazně rychlejší než brute-force algoritmus pro velkou abecedu Σ
c a b c d
L(c) 4 5 3 -1
3 Vyhledávání v řetězcích
86
KMP algoritmus Knuth-Morris-Prattův algoritmus
porovnává vzorek P s textem T zleva doprava, ale posouvávzorek inteligentněji než brute-force algoritmus
Když dojde k neshodě, jak můžeme co nejvíce posunout vzorek P, abychom vyloučili redundantní porovnávání?
Odpověď: Najdeme nejdelší prefix podřetězce P[0..j-1], který je i sufixem podřetězce P[1..j-1]
Není nutnéporovnávání
opakovat
Pokračovat v porovnáváníodtud
j=5
j=2
0 5
0 2
Nalezneme nejdelší předponuv "a b a a b" ( P[0..j‐1] ),shodnou s příponou v "b a a b" ( P[1 .. j‐1] ):Odpověď: "a b"Nová hodnota j = 2
3 Vyhledávání v řetězcích
87
Knuth-Morris-Prattův algoritmus předzpracovává vzorek, aby vyhledal shody prefixů vzorku se vzorkem samotným
Funkce neshody (failure function)F(k) je definována jako délka nejdelšího prefixu podřetězce P[0..k], který je zároveň sufixempodřetězce P[1..k], kde k=j-1 je pozice před neshodou
Knuth-Morris-Prattův algoritmus modifikuje prostý brute-force algoritmus tak, že pokud neshoda nastane v P[j] ≠ T[i], pokračujeme j ← F(j − 1)
k 0 1 2 3 4 5
P(k) a b a a b a
F(k) 0 0 1 1 2 3
k = j-1
Není nutnéporovnávání
opakovat
Pokračovat v porovnáváníodtud
3 Vyhledávání v řetězcích
88
Funkce neshody může být reprezentována polem a může být sestavena v čase O(m)
Při každé iteraci ve whilesmyčce:
i se zvyšuje o jedna, nebo
posunutí i − j se zvyšuje nejméně o jedna (přičemžF(j − 1) < j)
Smyčka tedy má složitost O(n)
Algorithm KMPMatch(T, P)F ← failureFunction(P)i ← 0j ← 0while i < n
if T[i] = P[j]if j = m − 1
return i − j match else
i ← i + 1j ← j + 1
elseif j > 0
j ← F[j − 1]else
i ← i + 1return −1 no match
KMP’s algoritmus běží v optimálním čase O(m + n) Algoritmus není příliš vhodný pro vyhledávání v textu (málo opakování v prefixu/sufixu),
je vhodný pro binární data
3 Vyhledávání v řetězcích
89
k=5: j F(k)=2
k
j 1 2 3 64 5
1 2 3 64 50 1 2 53 4
1 2 3 64 50 1 2 53 4
1 2 3 64 50 1 2 53 4
1 2 3 64 50 1 2 53 4
k=1: j F(k)=0
k=4: j F(k)=1
k=0: j F(k)=0
4 Grafové algoritmy
90
Základní pojmy
Graf G je dvojice (V,E). Prvky množiny V jsou vrcholy a prvkyjsou hrany.
Neorientovaný graf G značíme G(V,E), kde V je množina vrcholů a E je množina dvojic vrcholů z V, hrana e = u,v. Vrcholy jsou „body“ a hrany „spojnice“ vrcholů
Orientovaný graf G značíme G(V,E), kde V je množina vrcholů a E je množina uspořádaných dvojic vrcholů z V, hrana e = (u,v) počáteční vrchol hrany e se značí PV(e), koncový vrchol KV(e)
hrany se značí šipkou ve směru od počátečního vrcholu
neorientovaný graf lze převést na orientovaný nahrazením každé neorientované hrany u,v dvojicí orientovaných hran (u,v) a (v,u).
Pokud hrana začíná a končí ve stejném vrcholu, jedná se o smyčku
Pokud je více hran, které začínají ve stejném vrcholu a končí ve stejném vrcholu, říkáse těmto hranám násobné a grafu se říka multigraf
Počet vrcholů se značí |V| = n, počet hran se značí |E| = m
Hranám a (nebo) vrcholům mohou být přiřazeny nějaké hodnoty. Takovému grafu se říká ohodnocený.
4 Grafové algoritmy
91
Důležité množiny hran a vrcholů
V(G) – množina vrcholů grafu G
E(G) – množina hran grafu G
V(x) – množina sousedních vrcholů vrcholu x
V+(x) – množina následníků vrcholu x; vrcholy, do kterých vede hrana z x
V-(x) – množina předchůdců vrcholu x; vrcholy, ze kterých vede hrana do x
deg(x), d(x) – stupeň vrcholu x; počet hran, jejichž je x krajní vrchol (smyčky počítáme dvakrát)
deg + (x), d + (x) – výstupní stupeň vrcholu x; počet hran vycházejících z x
deg - (x), d - (x) – vstupní stupeň vrcholu x; počet hran vcházejících do x
Příklad:
4 Grafové algoritmy
92
Podgraf. Graf G’ je podgrafem grafu G, vznikne-li grafu G vynecháním nějakých (žádných) vrcholů a příslušných hran. Podgraf musí být stále grafem. Pokud je odebrán, musí být odebrány i všechny hrany, kterých je odebíraný vrchol součástí a pro každou hranu podgrafu do něo musí patřit oba krajní vrcholy.
Faktor grafu. Graf G’ je faktorem grafu G, vznikne-li pouze vynecháním hran, tzn. V(G) = V(G’).
Indukovaný (úplný) podgraf. Graf G’ je podgrafem indukovaným množinou vrcholů (úplným podgrafem na množině A), jestliže množina vrcholů G’je A a obsahuje všechny hrany grafu G, jejichž oba krajní vrcholy patří do A.
Sled. Posloupnost vrcholů a hran v0,e1,v1,e2,v2,...,en,vn nazýváme sledem, jestliže každá hrana ei spojuje vrcholy vi-1,vi (mohou se opakovat vrcholy i hrany)
Tah. Sled, ve kterém se neopakuje žádná hrana, se nazývá tah.
Cesta. Tah, ve kterém se neopakuje žádný vrchol se nazývá cesta.
Uzavřený sled (tah,cesta) je sled (tah,cesta), který začíná a končí ve stejném vrcholu.
4 Grafové algoritmy
93
Reprezentace grafu Seznam hran
Příklad: Neorientovaný graf na obrázku má 5 vrcholůA až E a seznam hran AB, AC, AD, BD, CD, DE.
Orientovaný graf má 4 vrcholy a až d
a seznam hran ab, ac, ba, cb a dc.
Matice sousednosti
Matice sousednosti obsahuje jen nuly nebo jednicky. Je-li graf ohodnocený, pro každou hranu budeme ukládat do matice ohodnocení aij hrany ij. Pokud aij uložíme vzdálenost vrcholu i od vrcholu j, tak dostaneme matici vzdáleností.
4 Grafové algoritmy
94
Seznam sousedůOrientovaný graf G = (V,E). Pro každý vrchol v si budeme
pamatovat seznam jeho sousedů.
Náhrada spojového seznamu - dvě pole: pole V[], obsahující ukazatele na začátky seznamů
pole Sousedi[], obsahující seznamy sousedů všech vrcholů
V[i] bude obsahovat index do pole Sousedi[], na kterém začíná seznam sousedů vrcholu i. Obě pole obsahují navíc zarážku.
Přehled reprezentacíReprezentace Je uv
hrana?Projít
sousedy vPaměťovánáročnost
seznam hran O(m) O(m) O(m)
matice sousednosti
O(1) O(n) O(n2)
seznam sousedů
O(n) O(#sousedů) O(n+m)
4 Grafové algoritmy
95
Úloha procházení grafu pravidla pro efektivní průchod grafem
každou hranou můžeme v každém směru projít maximálně jednou
hranou, kterou do vrcholu vstoupíme poprvé, se smíme vrátit, až když z daného
vrcholu nevede neprozkoumaná hrana
hranou, kterou vstoupíme do již navštíveného vrcholu, se ihned vracíme zpět
Vlastnosti
konečnost – zajišťuje první pravidlo - v každém kroku projdeme po jedné hrane,
každou hranu jen jednou a hran je jen konečně mnoho
korektnost – v souvislém grafu projdeme všechny hrany. Nejde-li aplikovat žádné z
pravidel, tak jsme v počátečním vrcholu a každou hranu jsme již prošli právě dvakrát
složitost - O(n+m) pokud je práce na každém vrcholu a hraně konstatntní - čas za
průchod je úměrný počtu hran m, které procházíme, a případná práce ve vrcholech
počtu vrcholů n.
4 Grafové algoritmy
96
Prohledávání do hloubky (DFS z anglického Depth First Search) V prvním vrcholu si vybereme jednu možnou hranu a po ní přejdeme do dalšího
vrcholu. Všechny procházené hrany označujeme. V každém vrcholu, do kterého přejdeme, ověříme: Pokud jsme v již dříve navštíveném vrcholu, vrátíme se zpátky do předchozího vrcholu.
Pokud je to dříve neprozkoumávaný vrchol, pokračujeme první možnou neprošlou hranou. Pokud taková hrana neexistuje, je vrchol zcela prozkoumán a vrátíme se do předchozího vrcholu.
Tímto postupem projdeme celý graf a nakonec se vrátíme do výchozího vrcholu.
4 Grafové algoritmy
97
Prohledávání do šířky (BFS z anglického Breadth First Search) průchod (prohledání grafu) ve vlnách – tzv. algoritmus vlny. Vyjdeme z vrcholu všemi
hranami (vlna) a při vstupu do dalších vrcholů se vlna znovu rozdělí po všech hranách.
Graf prozkoumáváme “po vlnách” V první vlně se dostaneme do vrcholů, do kterých vede z výchozího vrcholu hrana.
V druhé vlně se dostaneme do vrcholů, které jsou ve vzdálenosti 2 od výchozího vrcholu.
Podobně v k-té vlně se dostaneme do vrcholu ve vzdálenosti k od výchozího vrcholu.
Implementuje se obvykle tak, že při vstupu do nového vrcholu uložíme všechny možnécesty do fronty. Frontu průběžně zpracováváme.
atd....
4 Grafové algoritmy
98
Hledání nejkratší cesty v grafu
Nechť G=(V,E) je souvislý graf. Nechť w je funkce přiřazující každé hraně e z E reálnou hodnotu (cenu hrany). Chceme najít nejlevnější (nejkratší) cestu ze startovního vrcholu do cílového vrcholu.
Fakticky se hledají nejkratší sledy. Ty se ale rovnají nejkratším cestám, pokud ohodnocení hran grafu je nezáporné.
Dijkstrův algoritmus je algoritmus pro nalezení nejkratší cesty v grafu z vrcholu s do vrcholu t. Je konečný, protože v každém průchodu cyklu se do množiny navštívených uzlů přidá právě jeden uzel (průchodů cyklem je nejvýše tolik, kolik má graf vrcholů). Funguje nad hranově kladně ohodnoceným grafem (neohodnocený graf lze na ohodnocený snadno převést). Předpokládáme: Graf je souvislý
Graf má neorientované hrany
Graf má nezáporně ohodnocené hrany
Pro grafy s hranami se záporným ohodnocením se obvykle používá pomalejšíBellman-Fordův algoritmus.
4 Grafové algoritmy
99
Dijkstrův algoritmus
Mějme graf G, v němž hledáme nejkratší cestu. V je množina všech vrcholů grafu G,
množina E obsahuje všechny hrany grafu G.
Algoritmus pracuje tak, že si pro každý vrchol v z V pamatuje délku nejkratší cesty d[v], kterou se k němu dá dostat (na začátku: pro počáteční vrcholu s je d[s]=0, pro ostatní vrcholy d[v]=∞). Množina Z obsahuje už navštívené vrcholy a N dosud nenavštívené.
Algoritmus pracuje v cyklu tak dlouho, dokud N není prázdná. V každém průchodu cyklu se přidá jeden vrchol vmin z N do Z, a to takový, který má nejmenší hodnotu d[v] ze všech vrcholů v z N.
Relaxace hran: Pro každý vrchol u, do kterého vede hrana z vmin , se provede následující operace: pokud (d[vmin ] + l(vmin ,u)) < d[u], pak do d[u] d[vmin ] + l(vmin ,u), jinak nic.
Až algoritmus skončí, potom pro každý vrchol v z V je délka jeho nejkratší cesty od počátečního vrcholu s uložena v d[v]. relaxovaná
hranaPříklad: d(u)=50, d(z)=60, e=10
d(z) mind(z), d(u)+e
4 Grafové algoritmy
100
N: B C D E FZ: A
N: B D E FZ: A C
N: B E FZ: A C D
N: B FZ: A C D E
N: FZ: A C D E B
N:Z: A C D E B F
4 Grafové algoritmy
101
Dijkstra(G,w,s); G - graf, w - délka hran, s - startovní vrchol
for v je z V(G) do d[v] ← nekonečno; p[v] ← nedefinováno; endfor; d[s] ← 0 inicializace
Q ← V(G) množina všech vrcholů
while Q není prázdná do
u ← vrchol z Q s nejmenší hodnotou d[]
for v je sousedi[u] do
if d[v] > d[u]+w[u,v] then
d[v] ← d[u]+w[u,v]
p[v] ← u
endif
endfor
endwhile
Přečtení nejkratší cesty:S ← prázdná posloupnostu ← v; v – vrchol, do kterého hledáme nejkratší cestu while definováno p[u] do
přidej u na začátek Su ← p[u]
endwhile
v poli d[] se uchovává nejkratší dosud nalezená cesta ze startovního vrcholu
v poli p[] se uchovává předchůdce vrcholu na nejkratší cestě
jednoduchá implementace používá pro uložení prioritní fronty pole a operace extrakce vrcholu z Q je lineární prohledávání všech vrcholů v Q – pak je časová složitost O(|V|2+|E|), kde |V| je počet vrcholů a |E| počet hran.
Pro řídké grafy (počet hran << |V|2) může být algoritmus implementován efektivněji: graf se ukládá pomocíseznamu sousedů a funkce extrakce se implementuje pomocí binární haldy. – pak je časová složitost O(|E| + |V| log |V|)
Doporučená literatura
102
Další doporučená literatura, použitá v přednáškách: Michael T. Goodrich, Roberto Tamassia: Algorithm Design: Foundations,
Analysis, and Internet Examples. John Wiley & Sons, Inc., 2002, ISBN: 978-0-471-38365-9
Michael T. Goodrich, Roberto Tamassia: Data Structures and Algorithms in Java, 4th Edition. John Wiley & Sons, Inc., 2006, ISBN: 978-0-471-73884-8
S. Dasgupta, C. Papadimitriou, and U. Vazirani. Algorithms. McGraw-Hill Higher Education, 2007. On-line verze: http://www.cs.berkeley.edu/~vazirani/algorithms.html
Jakub Černý: Základní grafové algoritmy. MFF UK, 2008.On-line verze: http://kam.mff.cuni.cz/~kuba/ka/
Demo Dijkstrova algoritmu:http://www-b2.is.tokushima-u.ac.jp/~ikeda/suuri/dijkstra/Dijkstra.shtml
top related