Prednášky: pondelok 9:50 F1-247 a utorok 9:50 F1-109
Cvičenia:
- 1i1 (prvý krúžok) streda 9:50 M-217 Marek Zeman
- 1i2 (druhý krúžok) pondelok 12:20 H-3 Jana Katreniaková
- Rozdelenie na krúžky [1]
Nepovinné cvičenia: štvrtok 11:30 M-217 Marek Zeman (pre tých, ktorí si potrebujú učivo lepšie precvičiť alebo majú ďalšie otázky)

Vyučujúce

RNDr. Jana Katreniaková PhD., miestnosť M-263,
Mgr. Broňa Brejová, PhD., miestnosť M-163,

Cvičiaci

Mgr. Marek Zeman, miestnosť M-227,

Ciele predmetu

Naučiť sa algoritmicky uvažovať, písať kratšie programy a hľadať v nich chyby, porozumieť existujúcemu kódu
Oboznámiť sa so základnými programovými a dátovými štruktúrami jazyka C resp. C++, nie je však nutne so všetkými črtami týchto jazykov
- Cykly, podmienky, premenné a ich typy, funkcie a odovzdávanie parametrov, polia, smerníky, reťazce, súbory
Oboznámiť sa s niektorými základnými algoritmami a dátovými štruktúrami
- Triedenia, spájané zoznamy, hašovacie tabuľky, stromy, aritmetické výrazy, rad a zásobník, rekurzia, prehľadávanie, vyfarbovanie
Aj štruktúry, ktoré sú hotové v C++ knižniciach, si budeme programovať sami, aby sme videli, čo sa za nimi skrýva

Literatúra

Predmet sa nebude striktne riadiť žiadnou učebnicou. Prehľad preberaných tém a stručné poznámky nájdete na stránke predmetu, doporučujeme Vám si na prednáškach a cvičeniach robiť vlastné poznámky.
Pri štúdiu Vám môžu pomôcť knihy o jazykoch C a C++, o programovaní všeobecne a o algoritmoch preberaných na prednáške. Tu je výber z vhodných titulov, ktoré sú k dispozícii na prezenčné štúdium vo fakultnej knižnici:
- Prokop: Algoritmy v jazyku C a C++ praktický pruvodce, Grada 2008, I-INF-P-26
- Sedgewick: Algorithms in C. Parts 1-4 I-INF-S-43/I-IV
- Kochan: Programming in C, 2005 D-INF-K-7a
Referenčnú príručku k jazyku C++ nájdete napríklad na tejto webstránke: http://cplusplus.com/

Priebeh semestra

Na prednáškach budeme preberať obsah predmetu. Prednášky budú štyri vyučovacie hodiny do týždňa.
Cvičenia budú dve vyučovacie hodiny do týždňa v počítačovej učebni a ich cieľom je aktívne si precvičiť učivo. Na začiatku cvičenia bude krátka diskusia o prípadných nejasnostiach ohľadom materiálu z minulého cvičenia. Potom nasleduje rozcvička (krátky test) písaný na papieri. Ďalšou časťou cvičenia je precvičovanie príkladov k predchádzajúcim prednáškam (spoločne alebo individuálne).
Okrem toho sa každý týždeň konajú nepovinné cvičenia (tiež dve vyučovacie hodiny). Sú silne odporúčané pre študentov, ktorí doteraz programovali málo alebo vôbec, ale radi uvidíme aj tých, ktorým robia problémy niektoré ťažšie časti učiva, napríklad rekurzia alebo smerníky. Na tomto cvičení s pomocou cvičiaceho môžete dokončovať príklady z predchádzajúcich cvičení, pýtať sa otázky k učivu, prípadne pracovať na domácej úlohe.
Domáce úlohy navrhujeme tak, aby Vám ich riešenie pomohlo osvojiť si a precvičiť si učivo, čím sa okrem iného pripravujete aj na záverečnú skúšku. Okrem tohto sú za domáce úlohy body do záverečného hodnotenia. Najviac sa naučíte, ak sa Vám domácu úlohu podarí samostatne vyriešiť, ale ak sa vám to napriek vášmu úsiliu nedarí, neváhajte sa spýtať o pomoc prednášajúcich alebo cvičiacich. Možno s malou radou od nás sa Vám podarí úlohu spraviť. Treba však na domácej úlohe začať pracovať v predstihu, aby ste nás v prípade problémov stihli kontaktovať.
Cieľom vyučujúcich tohto predmetu je vás čo najviac naučiť, ale musíte aj vy byť aktívni partneri. Ak Vám na prednáške alebo cvičení nie je niečo jasné, spýtajte sa. Môžete nám klásť tiež otázky počas našich konzultačných hodín alebo emailom. Ak sa dostanete do väčších problémov s plnením študijných povinností, poraďte sa s vyučujúcimi alebo s tútorom, ako tieto problémy riešiť.
40% známky dostávate za domáce úlohy a rozcvičky, preto netreba nechávať štúdium učebnej látky až na skúškové obdobie.

Celkové odporúčania

Prichádzajúci študenti v prvom ročníku majú veľmi rôznu úroveň znalosti programovania, v závislosti od toho, koľko sa mu venovali na strednej škole. Preto pre niektorých môže byť tento predmet veľmi ľahký, pre iných veľmi ťažký. Môže sa to zdať nespravodlivé, ale pokročilí študenti už nad programovaním strávili dlhé hodiny a začiatočníci ich bez určitej námahy nikdy nedobehnú. Veľmi radi Vám však pomôžeme prekonať nástrahy tohto predmetu. Tu sú naše odporúčania podľa toho, aké znalosti už máte na začiatku semestra. Učebnú látku možno zhruba rozdeliť na základné programovacie konštrukty jazyka C resp. C++ a základné algoritmy, ktoré sa budú počas semestra striedať.

Úroveň znalostí	Náročnosť látky: základy programovania v C	Náročnosť látky: algoritmy, rekurzia	Odporúčanie
Programovať viem len málo alebo vôbec	ťažké	ťažké	Dôležité je začať usilovne pracovať už od začiatku semestra. Doporučujeme chodiť aj na nepovinné cvičenia, precvičovať si doma ďalšie príklady. Neváhajte sa nás spýtať, ak vám niečo nie je jasné.
Som skúsený programátor, ale neovládam C ani C++	ľahké	ťažké	Aj keď prvé prednášky sa Vám môžu zdať ľahké, sledujte učebnú látku, aby sa nestalo, že ste sa niektorými dôležitými vecami ešte nestretli. Nezabudnite robiť rozcvičky a domáce úlohy. Hlavne ale nezaspite na vavrínoch: už po pár týždňoch začneme preberať algoritmy a rekurziu, čo môžu byť pre Vás ťažšie témy. Treba preto zamakať aj na tomto predmete a v prípade, že Vám učivo robí problémy, neváhajte prísť aj na nepovinné cvičenia.
Som skúsený programátor a ovládam C alebo C++	viem	ťažké	Podobne ako predchádzajúci riadok. Môžete si prípadne skúsiť napísať test pre pokročilých, môže sa Vám podariť preskočiť zopár rozcvičiek.
Som skúsený programátor a ovládam aj rekurziu a základné algoritmy (napr. z programátorských súťaží alebo rozšírenej výučby programovania na strednej škole)	ľahké/viem	ľahké/viem	Aby ste sa nenudili písaním ľahkých rozcvičiek a domácich úloh, doporučujeme test pre pokročilých a pokročilé domáce úlohy. Aj tak však potrebujte absolvovať skúšku, prípadne aj záverečný test, takže priebežne sledujte učivo a v prípade nejasností sa pýtajte.

Zimný semester, pravidlá

Známkovanie

20% známky je na základe rozcvičiek, ktoré sa píšu na (takmer) každom cvičení
20% známky je za domáce úlohy
30% známky je za záverečný písomný test
30% známky je za praktickú skúšku pri počítači

Pozor, body získavané za jednotlivé príklady nezodpovedajú priamo percentám záverečnej známky. Body za každú formu známkovania sa preváhujú tak, aby maximálny získateľný počet zodpovedal váham uvedených vyššie. Úlohy označené ako bonusové sa nerátajú do maximálneho počtu získateľných bodov v danej aktivite.

Stupnica

Na úspešné absolvovanie predmetu je potrebné splniť nasledovné tri podmienky:
- Získať aspoň 50% bodov v celkovom hodnotení
- Získať aspoň 50% zo záverečného písomného testu
- Získať aspoň 50% zo skúšky
Ak niektorú z týchto troch podmienok nesplníte, dostávate známku Fx.
V prípade úspešného absolvovania predmetu získate známku podľa bodov v celkovom hodnotení takto:

A: 90% a viac, B:80...89%, C: 70...79%, D: 60...69%, E: 50...59%

Rozcvičky

Rozcvičky sú krátke testy (cca 15 minút), ktoré sa píšu na začiatku (takmer) každého cvičenia. Za každú rozcvičku môžete získať najviac 5 bodov.
Pri rozcvičke môžete použiť ľubovoľné písomné materiály (poznámky, knihy,...), nie však počítače a iné elektronické pomôcky. Počas rozcvičky nie je možné zdieľať materiály so spolužiakmi.
Ak bude počas semestra celkovo N rozcvičiek, do výslednej známky sa vám zaráta iba N-2 najlepších, t.j. dve rozcvičky, na ktorých ste získali najmenej bodov (alebo ste sa ich ani nezúčastnili) sa vám škrtajú.

Domáce úlohy

Domáce úlohy budú vypisované takmer každý týždeň. Maximálny počet bodov za domácu úlohu bude uvedený v zadaní a bude sa pohybovať spravidla v rozsahu 10-20 bodov podľa náročnosti úlohy.
Domáce úlohy treba odovzdať elektronicky pomocou odovzdávacieho systému do termínu určeného v zadaní. Neskoršie odovzdané úlohy nebudú akceptované.
Niektoré týždne budú vypísané aj špeciálne bonusové domáce úlohy, za ktoré môžete získať body navyše alebo dohnať body stratené na iných domácich úlohách. Bonusové úlohy sú však náročnejšie. Body za bonusovú úlohu môžete dostať iba ak máte základnú časť úlohy správne.
Program, ktorý odovzdáte ako domácu úlohu by mal byť skompilovateľný a spustiteľný v prostredí používanom na cvičeniach. Budeme kontrolovať správnosť celkovej myšlienky, správnosť implementácie ale body môžete stratiť aj za neprehľadný štýl.
Odovzdávací systém spustí vašu úlohu na jednoduchých vstupoch a dá vám vedieť, či došlo pri behu programe k nejakej chybe. Počas opravovania Váš program môžeme testovať aj na ďalších vstupoch. Programy, ktoré nebudú správne bežať na testovacích vstupoch nezískajú plný počet bodov, dajte preto pozor na všetky pokyny uveden v zadaní (presný formát vstupu a výstupu, mená súborov a podobne).

Záverečný písomný test

Záverečný test bude trvať 90 minút a bude obsahovať úlohy podobné tým, ktoré sa riešili na cvičeniach.
Riadny termín testu sa bude konať v kocom semestra, opravný termín počas skúškového obdobia.
Pri teste nemôžete používať žiadne pomocné materiály (písomné ani elektronické) okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách.

Skúška

Na skúške budete riešiť 2 úlohy pri počítači v celkovom trvaní 2-3 hodiny.
Na skúške nemôžete používať žiadne pomocné materiály okrem povoleného ťaháku v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách. Nebude k dispozícii ani internet. Budete používať rovnaké programátorské prostredie ako na cvičeniach.
Po skončení skúšky sa koná krátky ústny pohovor s vyučujúcimi, počas ktorého sa prediskutujú programy, ktoré ste odovzdali a uzavrie sa vaša známka.

Opravné termíny

Záverečný test má jeden opravný termín (je súčasťou priebežného hodnotenia)
- Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov.
Opakovanie skúšky sa riadi študijným poriadkom fakulty. Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili).
Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu.
Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi.
Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr.

Opisovanie

Máte povolené sa so spolužiakmi a ďalšími osobami rozprávať o domácich úlohách a stratégiách na ich riešenie. Kód, ktorý odovzdáte, musí však byť vaša samostatná práca. Je zakázané opisovať kód z literatúry alebo z internetu a ukazovať svoj kód spolužiakom. Domáce úlohy môžu byť kontrolované softvérom na detekciu plagiarizmu.
Počas rozcvičiek, testov a skúšok môžete používať iba povolené pomôcky a nesmiete komunikovať s žiadnymi osobami okrem vyučujúcich.
Ak nájdeme prípady opisovania, všetci zúčastnení študenti získajú za príslušnú domácu úlohu -5 bodov (aj študenti, ktorí dali spolužiakom odpísať). Opakované alebo obzvlášť závažné prípady opisovania alebo porušovania pravidiel predmetu budú podstúpené na riešenie disciplinárnej komisii fakulty.

Neprítomnosť

Účasť na cvičeniach veľmi silne doporučujeme a v prípade neprítomnosti stratíte body za rocvičky.
V prípade kratšieho ochorenia alebo iných problémov môžete využiť možnosť, že dve najhoršie rozcvičky sa škrtajú.
V prípade dlhšieho ochorenia (aspoň dva týždne alebo opakovaná neprítomnosť) alebo iných závažných prekážok sa príďte poradiť s prednášajúcimi o možných riešeniach. Treba tak spraviť čím skôr, nie až spätne cez skúškové. Prineste si potvrdenku od lekára.

Možnosti pre pokročilých programátorov

Študenti, ktorí už ovládajú väčšiu časť učiva na tento semester, majú možnosť získať známku zmysluplnejším spôsobom, ako písaním ľahkých rozcvičiek a domácich úloh.

Test pre pokročilých

V druhom týždni semestra sa bude konať nepovinný test pre pokročilých. Príklady na ňom budú podobné ako na záverečnom teste.
Ak na test prídete a napíšete ho na menej ako 50%, nezískate žiadne výhody (ako keby ste na test ani neprišli).
V opačnom prípade za každých celých získaných 10% získavate plný počet bodov z jednej rozcvičky. Napr. ak ste získali 59% z testu, dostanete plný počet bodov z prvých 5 rozcvičiek po opravení testu. Tieto body nie je možné presúvať na iné termíny rozcvičiek.
Navyše si môžete body z testu pre pokročilých nechať uznať ako body zo záverečného testu. Máte však aj možnosť písať záverečný test so spolužiakmi.

Domáce úlohy pre pokročilých

Namiesto bežných domácich úloh, ktoré budú menšie a odovzdávané skoro každý týždeň, ponúkame aj možnosť riešiť 4 väčšie a ťažšie domáce úlohy pre pokročilých.
Tieto domáce úlohy môžu vyžadovať aj znalosti nepreberané na prednáškach, ktoré si budete musieť doštudovať z odbornej literatúry.
Aby ste mohli namiesto bežných úloh robiť pokročilé, potrebujete povolenie od vyučujúcich. Všetci, čo napíšu test pre pokročilých aspoň na 50%, toto povolenie automaticky majú. Ostatní kontaktujte vyučujúce emailom a popíšte svoje programátorské skúsenosti.
Bežné a pokročilé DÚ nie je možné striedať, celý semester teda musíte odovzdávať ten istý typ úloh. Výnimkou je DÚ0, ktorú robia všetci študenti.

Nepreberané črty jazykov C a C++

Z jazykov C a C++ uvidíme len malú časť.
Preberané črty týchto jazykov je potrebné ovládať, pre vlastnú potrebu si však môžete v literatúre doštudovať aj ďalšie užitočné príkazy, knižnice a konštrukty.
Ak je v zadaní uvedené, aké prostriedky máte použiť, držte sa týchto pokynov.
V opačnom prípade môžete použiť aj nepreberané črty. Aby ste sa vyhli problémom pri opravovaní, je vhodné ich doplniť vysvetľujúcim komentárom.
Vždy používajte len štandardné súčasti jazykov C a C++ , nie špeciálne knižnice. (Výnimkou sú samozrejme knižnice poskytnuté vyučujúcimi).
Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod.

Zimný semester, test a skúška

Na tejto stránke budú postupne pribúdať informácie týkajúce sa záverečného písomného testu a praktickej skúšky pri počítači v zimnom semestri. Doporučujeme tiež si preštudovať pravidlá predmetu.

Termíny

Písomný test

Riadny termín piatok 13.12. o 14:00 v posluchárni B
Opravný/náhradný termín pondelok 13.1. o 14:00 v akváriu M-VII

Termíny skúšok vždy o 9:00:

9.1. M217, M218 (riadny termín)
22.1. H6 (riadny termín)
5.2. H6 (opravný termín)
12.2. M217, M218 (2. opravný termín)

Na termín skúšky sa zapisujte v systéme AIS. Ústna časť skúšky sa koná v poobedňajších hodinách ten istý deň.

Záverečná písomka

90 minút
Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
Jeden opravný termín

Čo musíte, môžete a nemôžete

Musíte:

index/ISIC
perá (pre istotu aj viac)

Môžete:

ťahák veľkosti A4

Nemôžete:

žiadne elektronické pomôcky (vypnúť mobily)
opisovať
iné materiály na stole (čisté papiere dostanete od nás)

Príklady

Bude zhruba 6 príkladov
- Príklad môže mať niekoľko podpríkladov, ktoré sú zároveň odporúčaným postupom krokov
Náročnosť zhruba ako rozcvičky
Dobre si rozvrhnite čas, niektoré úlohy sú ťažšie, iné ľahšie.

Typy príkladov:

napíšte funkciu, ktorá... (napr. na prácu so spájanými zoznamami, súbormi, stromami, rekurzia)
do funkcie nižšie doplňte chýbajúce časti tak, aby robila ... (dopĺňanie správnych typov, podmienok v cykloch a pod.)
zistite, čo vypíše funkcia pre nasledujúce vstupy...
čo spraví algoritmus z prednášky na danom vstupe, na akom vstupe sa bude správať takto a pod.
príklady na výrazy v postfixovej, prefixovej a infixovej forme, binárne vyhľadávacie stromy, zásobník a rad, ...

Skúška pri počítači

Termíny vypísané v AIS
Prineste si ISIC a index, písacie potreby na písanie pracovných poznámok, ťahák v rozsahu jedného listu A4. Žiadne ďalšie pomôcky nie sú povolené, nebude k dispozícii ani internet.
Stretávame sa vždy o 8:50 pred počítačovou halou (H6 alebo M217), kde sa dozviete pokyny a rozsadenie do miestností
Doobeda: 2 hodiny práca pri počítačoch.
- Prostredie ako na cvičeniach (Linux, Netbeans, ale môžete používať aj iné nainštalované editory, valgrind a pod.)
- Budete používať špeciálne skúškové konto, takže nebudete mať k dispozícii žiadne svoje súbory alebo nastavenia.
- Odovzdávanie prostredníctvom špeciálnej verzie testovača, slúži súčasne ako záloha.
Poobede: vyhodnotenie u prednášajúcich, zapisovanie známok.
Prihlasovanie/odhlasovanie na skúšku do 14:00 deň pred skúškou.
Aby ste mali šancu úspešne ukončiť predmet, musíte získať aspoň polovicu bodov.
- Na skúške sú dva príklady za rovnaký počet bodov
- Nie sú rovnako ťažké, preto si dobre premyslite, ako si rozdelíte čas.

Príklady

Na skúške budete riešiť dva príklady.
V prvom príklade budete mať za úlohu samostatne napísať celý program, ktorý rieši zadanú úlohu. Typicky bude treba načítať dáta, spracovať ich a vypísať výsledok.
- V tomto príklade môžete použiť ľubovoľný postup.
V druhom príklade dostanete kostru programu, pričom vašou úlohou bude doprogramovať niektoré funkcie.
- V tomto príklade môžete mať v zadaní predpísaný spôsob, ako máte niektoré časti naprogramovať.
- Budú sa vyžadovať aj zložitejšie časti učiva, ako napríklad zoznamy, stromy a rekurzia.
Nebudeme používať SVGdraw.
Môžete používať aj črty C/C++, ktoré sme nebrali. Používajte len štandardné súčasti jazyka. Vaše programy by mali fungovať v prostredí používanom v učebni bez zvláštnych nastavení kompilátora a pod.

Hodnotenie

V prvom rade budeme hodnotiť správnosť myšlienky vášho programu. Predtým, ako začnete programovať, si dobre rozmyslite, ako budete úlohu riešiť.
Ďalej je dôležité, aby sa program dal skompilovať (v štandardnom prostredí Netbeans) a aby správne fungoval na všetkých vstupoch spĺňajúcich podmienky v zadaní. Za nefunkčné programy môžete získať najviac polovicu bodov, aj keď ich myšlienka je správna.
V druhej úlohe budeme jednotlivé funkcie hodnotiť zvlášť, takže môžete získať čiastočné body, ak ste niekoľko funkcií správne napísali.
Hodnotiť budeme aj úpravu a štýl programu (komentáre, mená premenných, odsadzovanie, členenie dlhšieho programu na funkcie,...)
Na tejto skúške nezáleží na rýchlosti vášho programu. Radšej napíšte jednoduchý, prehľadný a hlavne správny pomalší program, než rýchlejší, ale zbytočne zložitý, či nesprávny.

Opravné termíny

Záverečný test má jeden opravný termín (je súčasťou priebežného hodnotenia)
- Ak sa zúčastníte opravného termínu, strácate body z predchádzajúceho termínu, aj keby ste na opravnom získali menej bodov.
Opakovanie skúšky sa riadi študijným poriadkom fakulty. Máte nárok na dva opravné termíny (ale len v rámci termínov, ktoré sme určili).
Ak po skúške pri počítači máte nárok na známu E alebo lepšiu, ale chceli by ste si známku ešte opraviť, musíte sa dohodnúť so skúšajúcimi pred zapísaním známky do indexu.
Ak po skúške pri počítači ešte opravujete písomku, je potrebné prísť uzavrieť a zapísať známku v termíne určenom vyučujúcimi.
Ak sa zo závažných dôvodov (napr. zdravotných, alebo konflikt s inou skúškou) nemôžete zúčastniť termínu skúšky alebo písomky, dajte o tom vyučujúcim vedieť čím skôr.

Ukážkové príklady na písomný test

V texte nižšie je niekoľko príkladov, ktoré sa svojim charakterom a obtiažnosťou podobajú na príklady, aké budú na záverečnej písomke. Tieto ukážkové príklady sú prevažne vybrané z cvičení a prednášok, na skutočnej písomke však budú nové, zatiaľ nepoužité príklady. Svoje odpovede si môžete skontrolovať nižšie.

Príklad 1: Zistite, čo vypíše nasledujúca funkcia, ak ju spustíme ako generuj(a, pocet, 0, 2, 3), pričom polia a a pocet majú dĺžku n=3 a obe sú naplnené nulami. Funkcia vypis(a,n) vypíše prvky poľa a.
- Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát?

void generuj(int a[], int pocet[], int i, int k, int n) {
    if (i == n) {
        vypis(a, n);
    } else {
        for (int x = 0; x < n; x++) {
            if (pocet[x]<k) {
                a[i] = x;
                pocet[x]++;
                generuj(a, pocet, i + 1, k, n);
            }
        }
    }
}

Príklad 2: Prepíšte výraz 8 3 4 * + 2 3 + / z postfixovej notácie do bežnej infixovej notácie

Príklad 3: Prepíšte výraz ((2+4)/(3*5))/(1-2) do postfixovej a prefixovej notácie

Príklad 4: Vyhodnocujeme výraz 8 3 4 * + 2 3 - / v postfixovej notácii algoritmom z prednášky. Aký bude obsah zásobníka v čase, keď začneme spracovávať znamienko +?

Príklad 5: Máme zásobník s a rad q, pričom obidve štruktúry uchovávajú dáta typu char. Aký bude ich obsah po nasledujúcej postupnosti príkazov?

init(s);
init(q);
push(s, 'A');
push(s, 'B');
push(s, 'C');
enqueue(q, pop(s));
enqueue(q, pop(s));
push(s, 'D');
push(s, dequeue(q));

Príklad 6: Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom.

Príklad 7: Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí).

Príklad 8: Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú niektorému reťazcu zo vstupu, zvýraznite dvojitým krúžkom.

Príklad 9: Uvažujme nasledujúcu rekurzívnu funkciu na vyfarbovanie. Predpokladajme, že a je matica s troma riadkami a troma stĺpcami vyplnená nulami, pričom funkciu spustíme na stredné políčko, t.j. stlpec=riadok=1 a nová farba je tiež 1. V akom poradí vyfarbí políčka matice novou farbou?

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu 
     * a[riadok][stlpec] na farbu farba */

    if (a[riadok][stlpec] != farba) {
        int stara_farba = a[riadok][stlpec];
        a[riadok][stlpec] = farba;
        if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok - 1, stlpec, farba);
        }
        if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok + 1, stlpec, farba);
        }
        if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec - 1, farba);
        }
        if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec + 1, farba);
        }
    }
}

Príklad 10: Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať.

Príklad 11: Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu.

Príklad 12: Nasledujúci program načíta od užívateľa počet kruhov, zoznam údajov pre jednotlivé kruhy (celočíselné súradnice a polomer), posunie každý kruh o 10 nižšie a zase kruhy vypíše. Doplňte do programu chýbajúce časti vyznačené čiarami (typy premenných, parametre a návratové typy funkcií).

#include <iostream>
using namespace std;

struct kruh {
   ________________
};

_______ posunKruh(__________) {
  k.y-=10;
}

_______ nacitajKruhy(__________) {
  _________ a;
  a = new kruh[n];
  for(int i=0; i<n; i++) {
    cin >> a[i].x >> a[i].y >> a[i].r;
  }
  return a;
}

______ vypisKruhy(________________) {
  for(int i=0; i<n; i++) {
    cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl;
  }  
}

int main(void) {
  _______ n;
  _______ a;
  cin >> n;
  a = nacitajKruhy(n);
  for(int i=0; i<n; i++) {
    posunKruh(a[i]);
  }
  vypisKruhy(a, n);
  delete[] a;
}

Príklad 13: Funkcia jeRastuci kontroluje, či sa hodnoty v spájanom jednosmernom zozname zvyšujú v smere od začiatku ku koncu zoznamu, t.j. či každý prvok je väčší ako jeho predchodca. Ak áno, vráti true, inak vráti false. Doplňte podmienky na podčiarknuté miesta tak, aby funkcia správne fungovala. V prípade, že zoznam je prázdny alebo obsahuje jeden prvok, odpoveď má byť true.

struct item {
    int data;
    item* next;
};

struct zoznam {
    item* zaciatok;
};

bool jeRastuci(zoznam &z) {
  item *v = z.zaciatok;
  while(____________) {
    if(_____________) {
      return false;
    }
    v = v->next;
  }
  return true;
}

Príklad 14: Uvažujme funkciu na triedenie vkladaním uvedenú nižšie.
- Koľkokrát sa vykoná riadok označený (**) na vstupnom poli (5,2,3,4,1)?
- Koľkokrát sa vykoná riadok označený (**) na vstupnom poli dĺžky n, ktoré je celé utriedené okrem toho, že najmenší a najväčší prvok sú vymenené teda (n,2,3,4,...,n-2,n-1,1)? Počet vykonaní zapíšte ako funkciu od dĺžky poľa n.

void insertionSort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for (int i = 1; i < n; i++) {
        int prvok = a[i];
        int kam = i;
        while (kam > 0 && a[kam - 1] > prvok) {
            a[kam] = a[kam - 1];  // (**) 
            kam--;
        }
        a[kam] = prvok;
    }
}

Vzorové riešenia ukážkových príkladov na písomný test

Príklad 1: funkcia vypíše tri trojice: 0 0 1, 0 0 2, 0 1 2. Nevypisuje to čo má, lebo po vynorení z rekurzie nezníži od pocet[x], aj keď hodnota a[i] bude zmenená z x na x+1. Tu je funkcia po oprave:

void generuj(int a[], int pocet[], int i, int k, int n) {
    if (i == n) {
        vypis(a, n);
    } else {
        for (int x = 0; x < n; x++) {
            if (pocet[x]<k) {
                a[i] = x;
                pocet[x]++;
                generuj(a, pocet, i + 1, k, n);
                pocet[x]--; /* pridany prikaz */
            }
        }
    }
}

Príklad 2: (8+3*4)/(2+3)
Príklad 3: postfix 2 4 + 3 5 * / 1 2 - / prefix: / / + 2 4 * 3 5 - 1 2
Príklad 4: na zásobníku budú čísla 8 a 12 (8 je na spodku zásobníka). Číslo 12 vzniklo vynásobením 3 a 4.
Príklad 5: na zásobníku budú znaky A, D, C (A na spodku zásobníka), v rade bude písmeno B
Príklad 6:

Príklad 7:

Príklad 8: (namiesto dvojiteho krúžku používame *)

          .
         / \
        /   \
       /     \ 
      a       b
     / \     /
    a   b   a*
   /   /   / \
  a   a*  a*  b*
 /
b*

Príklad 9: do každého políčka sme vpísali poradové číslo, kedy bude vyfarbené:

3 2 9
4 1 8
5 6 7

Príklad 10: Jedna možnosť je použiť dvojitý smerník, ktorý môže ukazovať buď na premennú zaciatok v zozname alebo na premennú next v niektorom jeho prvku.

void vyhod(zoznam &z) {
  /* vytvorime si smernik na miesto,
   * kde je ulozeny smenrik na dalsi prvok*/
  item **smernik = &(z.zaciatok);
  /* kym nie sme na konci zoznamu */
  while((*smernik)!=NULL) {
      /* dalsi prvok je nula, zmazeme ju a prevesime zvysok zoznamu */
      if((*smernik)->data==0) {
          item *remove = *smernik;
          (*smernik) = (*smernik)->next;
          delete remove;
      }
      /* dalsi prvok nie je nula, posunieme smernik */
      else {
          smernik = &((*smernik)->next);
      }
  }
}

Druhá možnosť je použiť dva cykly: jedným mažeme nuly na začiaktu a druhým mažeme nuly vo zvyšku zoznamu.

void vyhod(zoznam &z) {
    /* vyhadzujeme nuly na zaciatku */
    while (z.zaciatok != NULL && z.zaciatok->data == 0) {
        item * remove = z.zaciatok;
        z.zaciatok = remove->next;
        delete remove;
    }
    /* node bude ukazovat vzdy na nenulovy prvok,
     * kontrolujeme prvok za nim */
    item * node = z.zaciatok;
    while (node != NULL && node->next != NULL) {
        if (node->next->data == 0) {
            item * remove = node->next;
            node->next = remove->next;
            delete remove;
        }
        else {
            node = node->next;
        }
    }
}

Príklad 11:

int dvojicky(node *root) {
    /* prazdny strom neobsahuje dvojicky */
    if(root == NULL) return 0;
    
    int result = 0;
    /* ak su deti korena dvojicky, pricitaj 1*/
    if(root->left != NULL && root->right != NULL
            && root->left->data == root->right->data) {
        result++;
    }
    /* spocitaj dvojicky v lavom a pravom podstrome */
    result += dvojicky(root->left);
    result += dvojicky(root->right);
    return result;
}

Príklad 12:

#include <iostream>
using namespace std;

struct kruh {
    int x, y, r;
};

void posunKruh(kruh &k) {
  k.y-=10;
}

kruh * nacitajKruhy(int n) {
  kruh * a;
  a = new kruh[n];
  for(int i=0; i<n; i++) {
    cin >> a[i].x >> a[i].y >> a[i].r;
  }
  return a;
}

void vypisKruhy(kruh *a, int n) {
  for(int i=0; i<n; i++) {
    cout << " " << a[i].x << " " << a[i].y << " " << a[i].r << endl;
  }
}

int main(void) {
  int n;
  kruh * a;
  cin >> n;
  a = nacitajKruhy(n);
  for(int i=0; i<n; i++) {
    posunKruh(a[i]);
  }
  vypisKruhy(a, n);
  delete[] a;
}

Príklad 13:

bool jeRastuci(zoznam &z) {
    item *v = z.zaciatok;
    while (v != NULL && v->next != NULL) {
        if (v->data >= v->next->data) {
            return false;
        }
        v = v->next;
    }
    return true;
}

Príklad 14:
- Čísla 2,3,4 musia preskočiť číslo 5, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná 4 krát, spolu teda 7 krát.
- Čísla 2,3,4,...,n-2,n-1 musia preskočiť číslo n, riadok sa teda pre každé z nich vykoná raz a pre číslo 1 sa vykoná n-1 krát. Spolu sa teda riadok vykoná n-2+n-1=2n-3 krát.

Ukážkové príklady na skúšku pri počítači

Prvý príklad, verzia A

Vo vstupnom súbore matice.txt sú dve matice celých čísel. Každá matica má na prvom riadku počet riadkov m a počet stĺpcov n. Nasleduje samotná matica v m riadkoch, pričom každý obsahuje n čísel oddelených medzerami. Matice sú oddelené voľným riadkom.

Úlohou je vypísať súčet týchto dvoch matíc. V algebre spravidla sčitujeme matice rovnakého rozmeru, vo výslednej matici C je každé políčko súčtom zodpovedajúcich políčok vo vstupných maticiach A a B. V tomto zadaní ale môžeme mať aj matice rôznych rozmerov. V tom prípade matice najskôr rozšírime na spoločný rozmer. Ak majú napríklad rôzny počet riadkov, doplníme na spodok matice s menším počtom riadkov riadky vyplnené nulami tak, aby mala rovnaký počet riadkov ako druhá matica. Podobne pri rôznom počte stĺpcov pridávame na pravý okraj jednej matice stĺpce vyplnené nulami.

Uvažujme napríklad vstup s maticami rozmerov 2x1 a 1x4:

Po rozšírení budú mať obidve matice dva riadky a štyri stĺpce, budú teda vyzerať nasledovne:

Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle A=\left(\begin{array}{llll} 5 & 0 & 0 & 0 \\ 6 & 0 & 0 & 0 \\ \end{array}\right) \qquad B=\left(\begin{array}{llll} 1 & 2 & 3 & 4 \\ 0 & 0 & 0 & 0 \\ \end{array}\right) }

a ich súčet bude

Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle C=\left(\begin{array}{llll} 6 & 2 & 3 & 4 \\ 6 & 0 & 0 & 0 \\ \end{array}\right) }

Tento súčet matíc vypíšte do súboru sucet.txt v rovnakom formáte ako matice na vstupe, teda prvý riadok obsahuje rozmery matice a ďalej idú jednotlivé riadky matice s číslami oddelenými medzerami. Nedávajte medzeru pred prvé ani za posledné číslo v riadku. Pre uvedený príklad vstupu teda dostaneme výstup

2 4
6 2 3 4
6 0 0 0

V programe nepoužívajte polia konštantných veľkostí, program by mal vedieť spracovať ľubovoľné dáta, ktoré sa zmestia do pamäte (ak treba, alokujte polia dynamicky alebo použite štruktúry, ktoré menia veľkosť podľa potreby). Môžete predpokladať, že vstupný súbor existuje a má správny formát.

Prvý príklad, verzia B

Najdôležitejšie v tomto príklade je dobre navrhnúť, aké premenné, polia a prípadne iné dátové štruktúry použijete, nakoľko vhodná reprezentácia vstupných dát môže značne zjednodušiť program.

Vašou úlohou je spracovať údaje z pretekov. Zúčastnilo sa ich P pretekárov, ktorí sú očíslovaní číslami 0,...,P-1. Tieto čísla budeme volať aj štartovné čísla.

Preteky prebiehajú nasledovne: V teréne je rozmiestnených N stanovíšť, ktoré sú očíslované od 0 po N-1. Pretekári ich hľadajú a vždy keď nejaké stanovište nájdu, pošlú správu v tvare kto kam. Táto správa oznamuje, že účastník so štartovným číslom kto objavil stanovište s číslom kam. Pretekári môžu stanovištia prechádzať v ľubovoľnom poradí.

Môže sa stať, že pretekár omylom pošle správu o objavení určitého stanovišťa aj viackrát. Druhé a ďalšie objavenia stanovišťa tým istým pretekárom nemajú vplyv na výsledky pretekov.

Cieľom je vypísať výsledky pretekov, ktoré zahŕňajú poradie úspešných pretekárov a zoznam neúspešných pretekárov. Účastníci, ktorí objavia všetky stanovištia sú úspešní, ostatní sú neúspešní. Poradie úspešných pretekárov sa určuje podľa toho, kedy objavili svoje posledné stanovište. Neúspešní účastníci nemajú určené poradie, ich zoznam vypíšte usporiadaný podľa štartovného čísla.

Na prvom riadku vstupu sú celé čísla P a N. Potom nasleduje niekoľko riadkov so správami v poradí, v akom boli poslané účastníkmi.

Každá správa pozostáva z dvojice čísel kto kam, ktorá oznamuje, že účastník s číslom kto objavil stanovište s číslom kam. Môžete predpokladať, že každá správa je korektná a teda 0 <= kto <= P - 1 a 0 <= kam <= N - 1.

Úlohou Vášho programu je vypísať na štandardný výstup výsledky pretekov - poradie úspešných pretekárov a zoznam neúspešných pretekárov. Dodržte formát z príkladov nižšie. V prípade, že žiadni účastníci neboli neúspešní by mal po dvojbodke v poslednom riadku hneď nasledovať znak

nového riadku a za ním koniec výstupu.

V programe je zakázané používať polia konštantných veľkostí. Program by mal vedieť spracovať ľubovoľne veľké dáta, ktoré sa zmestia do pamäte (alokujte polia dynamicky alebo použite štruktúry, ktoré menia veľkosť podľa potreby).

Príklady:

Vstup:

Výstup:

1. skoncil 0
2. skoncil 2
Neuspesni ucastnici: 1 3

Vstup:

Výstup:

1. skoncil 2
2. skoncil 0
3. skoncil 1
Neuspesni ucastnici:

Vstup:

Výstup:

Neuspesni ucastnici: 0 1 2

Druhý príklad

Tento príklad je prevzatý z cvičení, na skúške budú príklady, ktoré doteraz neboli použité.

Napíšte program, ktorý udržuje množinu celých čísel, pričom od užívateľa jeden po druhom načítava príkazy, ktoré aj hneď aj vykonáva. Každý príkaz pozostáva z jednopísmenového kódu a z celočísleného parametra, ktoré užívateľ zadá na jednom riadku. Príkazy sú štyroch typov:

Príkaz s kódom 'I' vloží zadané číslo do množiny (na začiatku programu je množina prázdna). Vypíše buď reťazec OK, ak sa podarilo číslo vložiť, alebo reťazec ERR, ak už číslo v množine bolo.
Príkaz s kódom 'R' dostane ako parameter prvok x a zistí, koľký v utriedenom poradí tento prvok je v rámci množiny. Ak zadané číslo nie je z množiny, vypíše reťazec ERR, v opačnom prípade vypíše výsledok, ktorý by mal byť číslo od 1 po počet prvkov množiny.
Príkaz s kódom 'S' nájde k-te najmenšie číslo v množine, pričom k je zadaný parameter, ktorý by mal byť v rozsahu od 1 po počet prvkov množiny. Ak k nie je v tomto rozsahu, program vypíše reťazec ERR, v opačnom prípade vypíše nájdený prvok.
Príkaz s kódom 'E' ukončí program, parameter ignoruje.

Príklad:

I 20
OK
I 20
ERR
I 10
OK
R 20
2
S 2
20
R 30
ERR
E 0

Tento problém budeme riešiť modifikáciou binárnych vyhľadávacích stromov. Každý vrchol bude obsahovať kľúč typu int, smerník na ľavého a pravého syna, smerník na otca a počet vrcholov v celom podstrome zakorenenom v danom vrchole (položka count). Napríklad pre list by mal byť count 1, pre vrchol s dvoma synmi, ktorí sú obaja listami, by hodnota count mala byť 3.

V programe uvedenom nižšie máte funkcie z prednášky na vkladanie prvku do vyhľadávacieho stromu a jeho vyhľadávanie ako aj základ funkcie main. Vašou úlohou je doprogramovať nasledovné časti kódu:

Funkcie createLeaf a insert zmeňte tak, aby správne inicalizovali a udržiavali položku count pre všetky vrcholy v strome.
Funkcie rank a select (pozri nižšie)
Dopísať spracovanie príkazov R a S do hlavného programu.

Čiastočné body môžete dostať aj ak sa vám podarí spraviť správne iba niektoré z týchto podúloh, nemeňte však celkovú kostru programu. V prípade potreby si napíšte aj ďalšie funkcie, ktoré budete z uvedených funkcií volať.

Funkcia int rank(dictionary &d, int key) má nájsť prvok key v strome a vrátiť, koľký v utriedenom poradí spomedzi iných prvkov v strome je. V tejto funkcii predpokladajte, že hľadaný kľúč sa v strome určite nachádza (prípad, že sa nenachádza doriešte v hlavnom programe). V tejto funkcii využite položku count. Ak totiž pokračujeme v hľadaní v pravom podstrome určitého vrcholu v, tak vrchol v aj všetky vrcholy v jeho ľavom podstrome sú pred hľadaným prvkom. A aj bez toho, aby sme ľavý podstrom celý prechádzali, vieme koľko prvkov v ňom je.

Funkcia int select(dictionary &d, int k) má vrátiť k-ty najmenší prvok vo vyhľadávacom strome. Aj v tejto funkcii využite položku count. Ak je totiž k najviac rovné počtu vrcholov v ľavom podstrome, k-ty najmenší prvok musí byť niekde v tomto podstrome. Ak je naopak k veľké, hľadaný prvok musí byť v pravom podstrome a vieme spočítať aj to, koľký najmenší v rámci tohto podstromu je.

#include <iostream>
#include <cassert>
using namespace std;

struct node {
    /* vrchol binarneho vyhladavacieho stromu  */
    int key; /* kluc podla ktoreho vyhladavame */
    int count; /* pocet vrcholov v podstrome */
    node * parent; /* otec vrchola */
    node * left; /* lavy syn */
    node * right; /* pravy syn */
};

struct dictionary {
    node *root;
};

void init(dictionary &d) {
    /* inicializuje prazdny slovnik */
    d.root = NULL;
}

node * createLeaf(int key, node * parent) {
    /* vytvor novy vrchol s danymi hodnotami, obe deti nastav na NULL */
    node *v = new node;
    v->key = key;
    v->left = NULL;
    v->right = NULL;
    v->parent = parent;
    return v;
}

node * findNode(node *root, int key) {
    /* V binarnom vyhladavacom strom s korenom root najdi a vrat
     * vrchol s klucom a ak neexistuje, vrat NULL. */
    node * v = root;
    while (v != NULL && v->key != key) {
        if (key < v->key) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
    return v;
}

void findNode(node *root, int key, node *&v, node *&parent) {
    /* Do v uloz smernik na vrchol s klucom key alebo NULL ak neexistuje.
     * Do parent uloz otca v, NULL ak neexistuje a ak key nie je v strome
     * tak smernik na vrchol, ktory by mal byt otcom pre vrchol
     * s hodnotou key.*/
    parent = NULL;
    v = root;
    while (v != NULL && v->key != key) {
        parent = v;
        if (key < v->key) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
}

bool find(dictionary &d, int key) {
    /* Zisti, ci sa v slovniku d nachadza kluc key. */
    node *v = findNode(d.root, key);
    if (v != NULL) {
        assert(v->key == key);
        return true;
    } else {
        return false;
    }
}

void insert(dictionary &d, int key) {
    /* Do slovnika d vlozi kluc key.
     * Predpokladame, ze takyto kluc este v slovniku nie je. */
    if (d.root == NULL) {
        /* prazdny strom - treba vytvorit koren */
        d.root = createLeaf(key, NULL);
    } else {
        node *v;
        node *parent;
        findNode(d.root, key, v, parent);
        /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */
        assert(v == NULL && parent != NULL);
        /* zisti, ci mame byt lave alebo prave dieta otca */
        if (key < parent->key) {
            assert(parent->left == NULL);
            parent->left = createLeaf(key, parent);
        } else {
            assert(parent->right == NULL);
            parent->right = createLeaf(key, parent);
        }
    }
}

int rank(dictionary &d, int key) {
    /* vrati kolky je key v utriedenom poradi prvkov v strome.
     * Predpoklada, ze key sa v strome nachadza. */
}

int select(dictionary &d, int k) {
    /* vrati k-ty najmensi prvok v strome.
     * Predpoklada, ze 1 <= k <= celkovy pocet prvkov v strome. */
}

int main() {
    dictionary d;
    init(d);

    while (true) {
        char command;
        int param;
        cin >> command >> param;
        switch (command) {
            case 'I':
                if (find(d, param)) {
                    cout << "ERR" << endl;
                } else {
                    insert(d, param);
                    cout << "OK" << endl;
                }
            case 'S':
                break;
            case 'R':
                break;
            case 'E': return 0;
        }
    }
}

Netbeans

Ako spustiť Netbeans v učebni

Po spustení počítača zvoľte Linux a prihláste sa pomocou toho istého mena a hesla, ako používate v systéme AIS
V ľavom dolnom rohu obrazovky je menu s ponukou programov, v oddelení Development nájdete Netbeans

Základy práce v Netbeans

Vytvorenie nového projektu

Každý program v Netbeans potrebuje svoj "projekt", čo je adresár so všetkými potrebnými súbormi.
V menu zvoľte File, potom New project
V Categories zvoľte C/C++, v Project: C/C++ Application
Na ďalšej obrazovke projekt nejako nazvite a zvoľte do akého adresára sa má uložiť (Project Location). Doporučujeme cestu na svieťovom disku net, ku ktorému máte prístup zo všetkých počítačov v učebniach, napríklad v adresári /home/x/vasemeno/net/NetBeansProjects
Stlačte Finish

Editovanie programu

V ľavej časti okna máte panel Project, v ktorom nájdite projekt, ktorý ste práve vytvorili.
V projekte rozbaľte Source Files a nájdete tam main.cpp, ktorý si dvojitým kliknutím otvoríte v editore. Jeho obsah môžete modifikovať alebo celý zmazať a nahradiť programom z prednášky.
Súbor main.cpp nezabudnite uložiť (menu File, Save, alebo Ctrl-S)

Kompilovanie a spúšťanie

V menu Run zvoľte Build main project (F11), program sa skompiluje. Prípadné chyby sa objavia v dolnej časti okna.
V menu Run zvoľte Run main project (F6), program sa spustí.
Ak máte naraz otvorených viac projektov, jeden z nich je hlavný, vyznačený hrubým písmom. Kompilovanie a spúšťanie sa aplikuje na hlavný projekt.
- Ak chcete nastaviť nejaký projekt ako hlavný, kliknite na jeho meno v paneli Project pravým tlačidlom a zvoľte Set as main project

Prenášanie programov a odovzdávanie domácich úloh

Pri odovzdávaní domácich úloh odovzdávajte súbor main.cpp s vašim programom (prípadne ďalšie súbory ak to vyžaduje zadanie). Tento súbor nájdete v adresári net/NetBeansProjects/menoprojektu
Ak pracujete na rôznych počítačoch v rámci FMFI učební, svoje projekty si ukladajte na sieťovom disku net
Dáta zo sieťového disku si môžete stiahnuť v učebni na USB kľúčik, alebo aj cez sieť z domu prihlásením sa na študentský Linuxový klaster daVinci (davinci.fmph.uniba.sk). Na prenos dát môžete použiť napríklad windowsovský program winscp
Ak chcete prenášať projekt medzi rôznymi počítačmi, doporučujeme skopírovať iba main.cpp, prípadne ďalšie potrebné súbory.
- Na druhom počítači vytvoríte nový projekt, nakopírujete main.cpp do jeho adresára.
- Potom pridáte main.cpp do projektu takto: kliknite pravým tlačidlom na Source Files v paneli Projects, zvoľte Add Existing Item

Práca v Netbeans s grafickou knižnicou SVGdraw

Stiahnite si knižnicu
- Stiahnuté súbory SVDdraw.cpp a SVGdraw.h uložte do adresára NetBeansProjects, v ktorom podadresáre obsahujú jednotlivé projekty
Po vytvorení projektu kliknite pravým tlačidlom na Source Files v paneli Projects, zvoľte Add Existing Item, prejdite o adresár vyššie (do NetBeansProjects) a pridajte oba súbory SVDdraw.cpp a SVGdraw.h
Do súboru main.cpp potom píšte program používajúci knižnicu, pričom na prvom riadku uvediete #include "../SVGdraw.h"
Po spustení programu sa vám SVG súbor s obrázkom vytvorí v adresári so súbormi projektu
- Knižnica vie vytvárať aj animované obrázky, tie však väčšina prehliadačov nevie správne zobraziť. Doporučujeme ich otvoriť v internetovom prehliadači, napr. vo firefoxe.

Práca s Netbeans na vlastnom počítači

Ak máte na počítači operačný systém Linux, budete potrebovať nainštalovať nasledujúce softvérové balíčky:

Prostredie netbeans (v učebni máme verziu 6.9.1., mala by však postačovať aj iná verzia)
Komplilátor g++
Debuger gdb

Všetky tieto balíčky existujú napríklad v distribúcii Ubuntu. Ak vo vašej distribúcii nie je k dispozícii balíček pre Netbeans, stiahnite si ho zo stránky http://netbeans.org/downloads/

Po nainštalovaní týchto balíčkov spustite Netbeans, v menu Tools zvoľte Plugins a pridajte si plugin C/C++ (možno bude potrebné v záložke Settings okna Plugins zvoliť zdroje pluginov a stlačiť Reload Catalog).

Ak máte na počítači operačný systém Windows, je možné tiež si nainštalovať Netbeans a kompilátor C++, postupujte podľa návodu https://netbeans.org/community/releases/70/cpp-setup-instructions.html

Ak máte Windows, ale chceli by ste si vyskúšať aj prácu v Linuxe, doporučeme si nainštalovať Linux do virtuálneho počítača, napr. pomcou programu VirtualBox.

SVGdraw

Knižnica SVGdraw umožňuje vytvoriť obrázok v SVG formáte a vykresľovať do neho rôzne geometrické útvary, animovať ich a používať korytnačiu grafiku.

Návod na použitie knižnice v prostredí Netbeans
Stiahnutie knižnice
Príklady programov na prvej prednáške

Vykresľovanie v SVG formáte

Ako prvé musíme vytvoriť súbor s obrázkom v SVG formáte s určitými rozmermi príkazom typu SVGdraw drawing(150, 100, "hello.svg");
Do obrázku môžeme kresliť príkazmi drawRectangle, drawEllipse, drawLine, drawText.
Ak chceme vykresľovať mnohouholníky, použijeme skupinu príkazov startPolygon, addPolygonPoint a drawPolygon. Pomocou startPolygon a addPolygonPoint postupne vymenujeme vrcholy a pomocou drawPolygon mnohouholník uzavrieme a vykreslíme.
Pomocou príkazov setLineColor, setFillColor, setNoFill nastavujeme farbu čiar a vyfarbovania. Farby zadávame buď troma číslami od 0 do 255 určujúcimi intenzitu červenej, zelenej a modrej, alebo názvom, napr. "red" (zoznam mien farieb). Príkaz setFontSize nastavuje veľkosť písma a setLineWidth nastavuje hrúbku čiary.
Po vykreslení všetkých útvarov ukončíme vykresľovanie príkazom drawing.finish();
Po spustení programu by vám mal vzniknúť súbor hello.svg, ktorý si môžete prezrieť napríklad v internetovom prehliadači.

Animácie

Príkaz wait umožní pozastaviť vykresľovanie SVG súboru o zadaný čas v sekundách, takže jednotlivé útvary sa objavujú postupne.
Príkaz clear schová všetky vykreslené útvary, takže môžeme kresliť znova na prázdnu plochu. Pred príkazom clear je vhodné použiť wait.
Príkaz hideItem schová objekt (napr. čiaru) so zadaným číslom. Každý kresliaci príkaz vráti číslo práve vykresleného objektu, takže si ho stačí uložiť v nejakej premennej pre neskoršie mazanie.

Príkazy pre korytnačiu grafiku

Namiesto vykresľovania obdĺžnikov, čiar a pod na zadané súradnice môžeme obrázok vytvoriť aj korytnačou grafikou. Na obrázku bude pohyb korytnačky znázornený ako červený trojuholník a za sebou bude nechávať čiernu čiaru.

Príkazom typu Turtle turtle(200, 300, "domcek2.svg", 50, 250, 0); vytvoríme SVG obrázok určitej veľkosti a s určitým menom súboru. Posledné tri čísla udávajú počiatočnú polohu korytnačky a jej natočenie.
Korytnačka si pamätá svoju polohu a natočenie na ploche. Príkaz forward posunie korytnačku dopredu, príkazy turnLeft a turnRight ju otočia.
Príkaz setSpeed umožňuje zmeniť rýchlosť korytnačky, aby sme lepšie videli, ako sa postupne hýbe.

Prednáška 1

Pozrite si úvod k predmetu a pravidlá.

Čo je programovanie

Algoritmus

Algoritmus: Postupnosť konečného počtu elementárnych krokov vedúca k vyriešeniu daného typu úlohy

Príklady:

Ako sčítať dve celé čísla v desiatkovej sústave
Ako nájsť najväčšieho spoločného deliteľa dvoch čísel
Ako riešiť Sudoku

Správnosť algoritmu

Keď vždy dáva správne výsledky.
Keď vždy skončí.

Program

Predpis, pomocou ktorého počítač môže vykonávať algoritmus
Zapísaný v programovacom jazyku

Programátorské prostredie

Na tomto predmete budeme programovať v jazyku C++, budeme však z neho používať len malú časť.
Budeme používať programátorské prostredie NetBeans, ktoré vám spríjemňuje a zjednodušuje prácu.
Cvičenia a skúšky budú v operačnom systéme Linux

Môžete používať aj iné programátorské prostredia, ale
- odovzdané programy (DÚ, skúška) musia správne pracovať v prostredí ako na cvičeniach
- počas skúšky budete mať k dispozícii len to, čo beží v učebniach v Linuxe

Netbeans a ďalšie potrebné nástroje si môžete nainštalovať zadarmo aj na vašom počítači
- Návod k práci v prostredí Netbeans

Prvý program

Tradične sa v učebniciach programovania ako prvý uvádza program, ktorý iba vypíše na obrazovku text "Hello world!". Tu je v jazyku C++:

#include <iostream>
using namespace std;

int main(void) {
    cout << "Hello world!" << endl;
}

Samotný text je vypísaný príkazom cout << "Hello world!" << endl;
Všimnite si, že text Hello world! sme dali do úvodzoviek, čím poukazujeme na to, že to nie sú príkazy programovacieho jazyka, ale text, s ktorým treba niečo robiť.
Za príkazom sme dali bodkočiarku, ktorá ho ukončuje.
O vypisovaní si povieme viac neskôr, ale už teraz môžete vypisovať rôzne texty tým, že zmeníte text medzi úvodzovkami.

Riadok int main(void) { označuje začiatok programu, program ide až po ukončovaciu zloženú zátvorku }
Jazyk C++ sám o sebe neobsahuje príkazy na vypisovanie (cout <<...). Na to potrebujeme použiť knižnicu: súbor príkazov, ktoré niekto už naprogramoval a my ich len používame. Prvé dva riadky programu nám umožnia používať štandardnú knižnicu iostream, ktorá je súčasťou C++ a ktorá obsahuje príkazy na vypisovanie.

Spúšťanie programu

Na to, aby sme náš program mohli spustiť na počítači, potrebujeme ho najskôr skompilovať, t.j. preložiť do spustiteľného strojového kódu.
Ako na to, nájdete v návode k práci v prostredí Netbeans
V prostredí Netbeans vieme program aj spustiť, môžeme si ho však aj skopírovať a spúšťať na iných počítačoch nezávisle od Netbeans.

Prvý grafický program

Občas budeme vykresľovať obrázky pomocou knižnice SVGdraw vytvorenej špeciálne pre tento predmet. (Tu je návod na jej používanie)
Nasledujúci program vypíše text Hello world! pomocou tejto knižnice.

#include "../SVGdraw.h"

int main(void) {
    /* Vytvor obrázok s rozmermi 150x100 pixelov a 
     * ulož ho do súboru hello.svg*/
    SVGdraw drawing(150, 100, "hello.svg");

    /* Nastav farbu na červenú. */
    drawing.setLineColor("red");

    /* Vypíš text vystredený na súradniciach 75,50. */
    drawing.drawText(75, 50, "Hello world!");

    /* Ukonči vypisovanie obrázka. */
    drawing.finish();
}

Výsledný obrázok

Po spustení program vypíše text červenou farbou a uloží ho vo forme obrázku do súboru hello.svg.
Prvý riadok programu teraz obsahuje inú knižnicu (SVGdraw). Nie je súčasťou jazyka, preto si ju musíme skopírovať na náš počítač a umiestniť do vhodného adresára. Viac v návode.

Medzi int main(void) { a koncovou zátvorkou } máme teraz viacero príkazov, každý ukončený bodkočiarkou. Vykonávajú sa v tom poradí, v ako sú napísané.
Text medzi /* a */ bude počítač ignorovať, ide o komentár určený pre čitateľa. V tomto prípade vždy popisuje, čo bude robiť nasledujúci riadok.

Cvičenia

Aj keď sme si nepovedali toho veľa o jednotlivých príkazoch v tomto programe, mali by ste z komentárov vedieť uhádnuť, ako meniť program aby napríklad:

mal inú veľkosť obrázku
použil na vypisovanie inú farbu
vypísal text na iné miesto v rámci obrázku
vypísal dva rôzne texty na rôzne miesta obrázku rôznou farbou (napr. červeným Hello world! a pod to modrým Good morning, starshine!)
uložil obrázok do súboru s iným menom

Vykreslenie domčeka

Tradičný preškrtnutý domček

Domček so súradnicami

Ukážeme si ešte program, ktorý vykreslí tradičný prečiarknutý domček, ako je na obrázku vpravo.
Pozor, grafická obrazovka má súradnicu 0,0 v ľavom hornom rohu a smerom nadol y-ová súradnica stúpa, čo je naopak, než je zvykom v matematike.

#include "../SVGdraw.h"

int main(void) {
    /* Vytvor obrázok s rozmermi 200x300 pixelov a 
     * ulož ho do súboru domcek1.svg*/
    SVGdraw drawing(200, 300, "domcek1.svg");

    /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 50, 150
     * a šírkou aj dĺžkou 100. */
    drawing.drawRectangle(50, 150, 100, 100);

    /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */
    drawing.drawLine(50, 250, 150, 150);
    drawing.drawLine(50, 150, 150, 250);

    /* Nakresli strechu ako dve čiary. */
    drawing.drawLine(50, 150, 100, 50);
    drawing.drawLine(150, 150, 100, 50);

    /* Ukonči vypisovanie obrázka. */
    drawing.finish();
}

Obmenou týchto dvoch programov by ste mali vedieť vykresliť hocijaký obrazec z rovných čiar a pridať k nim text.
Knižnica SVGdraw umožnuje vykresľovať aj kružnice a elipsy, mnohouholníky, meniť farbu čiary, vyfarbovať útvary a podobne. Viac sa dočítate v návode.

Domček korytnačou grafikou

Pointa preškrtnutého domčeka je, že sa má kresliť jedným ťahom. To náš program vyššie nerobil.
Knižnica SVGdraw obsahuje aj príkazy na korytnačiu grafiku, ktorou môžeme domček nakresliť jedným ťahom.
- Vytvoríme si virtuálnu korytnačku, ktorá má určitú polohu a natočenie.
- Môžeme jej povedať, aby sa otočila doľava o určitý počet stupňov (turtle.turnLeft(uhol) a turtle.turnRight(uhol)).
- Môžeme jej povedať, aby išla o určitú dĺžku dopredu (turtle.forward(dlzka))
- Keď ide korytnačka dopredu, zanecháva v piesku chvostom čiarku (vykreslí teda čiaru do nášho obrázku).

#include "../SVGdraw.h"
#include <cmath>

int main(void) {
    /* Vytvor korytnačku na súradniciach (50,250) 
     * otočenú doprava na obrázku s rozmermi 200x300 pixelov,
     * ktorý bude uložený do súboru domcek2.svg. */
    Turtle turtle(200, 300, "domcek2.svg", 50, 250, 0);

    /* Nakresli dolnú čiaru a otoč sa smerom hore. */
    turtle.forward(100);
    turtle.turnLeft(90);

    /* Nakresli pravú zvislú čiaru, hornú vodorovnú a ľavú zvislú. */
    turtle.forward(100);
    turtle.turnLeft(90);
    turtle.forward(100);
    turtle.turnLeft(90);
    turtle.forward(100);

    /* Otoč sa smerom na uhlopriečku.
       Dĺžku uhlopriečky vyrátame Pytagorovou vetou. */
    turtle.turnLeft(135);
    turtle.forward(sqrt(100 * 100 + 100 * 100));

    /* Otoč sa smerom na pravú časť strechy.
     * Strecha bude rovnostranný trojuholník so stranou
     * dĺžky 100. */
    turtle.turnLeft(75);
    turtle.forward(100);
    turtle.turnLeft(120);
    turtle.forward(100);

    /* A posledná čiara - uhlopriečne prečiarknutie. */
    turtle.turnLeft(75);
    turtle.forward(sqrt(100 * 100 + 100 * 100));

    /* Ukonči vypisovanie obrázka. */
    turtle.finish();
}

Pre jednoduchosť tento domček má trochu nižšiu strechu v tvare rovnostranného trojuholníka s každou stranou dĺžky 100 (a vnútornými uhlami 60 stupňov)
Keďže domček je štvorec, uhlupriečka ide pod uhlom 45 stupňov. Jej dĺžku však musíme spočítať. Na sčítavanie používame znamieko +, na násobenie *, a na odmocninu funkciu sqrt (skratka z anglického square root), ktorá je v knižnici cmath
Na obrázku sa animuje pohyb korytnačky (pozri tu)

Zhrnutie

Programy, ktoré sme doteraz videli, vyzerali takto:
- Najprv sme zapli používanie niekoľkých knižníc
- Samotný program začínal int main(void) { a končil zloženou zátvorkou }
- Program mohol mať niekoľko príkazov ukončených bodkočiarkami, ktoré sa vykonávajú jeden po druhom.
- Okrem toho môžu byť v programe komentáre medzi /* a */, ktoré počítač ignoruje.

Logiku za tým, prečo jednotlivé príkazy píšu tak, ako sa píšu, sme zatiaľ ešte nevysvetľovali, mali by ste však byť schopní modifikovať príklady uvedené v prednáške menením čísel, textov v úvodzovkách, pridávaním ďalších príkazov a podobne.

Upozornenia:
- Je rozdiel medzi malými a veľkými písmenami
- Všetky čiarky, bodkočiarky, zátvorky a podobne sú dôležité
- Na väčšine miest v programe môžeme voľne pridávať medzery a konce riadku, snažíme sa tým program spraviť prehľadný

Programy, ktoré sme videli doteraz nie sú veľmi zaujímavé, lebo vždy robia to isté a robia pevný počet krokov, ktoré sme museli ručne všetky vypísať. Ďalej uvidíme
- príkazy na načítanie vstupu od užívateľa
- premenné, v ktorých si môžeme uchovávať vstupy a iné hodnoty
- podmienky, ktoré nám umožnia vykonávať príkazy podľa okolností
- cykly, ktoré nám umožnia opakovať tie isté príkazy veľa krát

Organizačné poznámky

Dnes a v stredu prvé cvičenia
- Budete potrebovať prihlasovacie meno a heslo do AIS2 na prihlásenie v učebni
- Skúste odovzdat DÚ0
Zajtra ďalšia prednáška a zverejnenie DÚ1
Do piatka odovzdať DÚ0 a prihlásiť sa na test pre pokročilých
Budúci týždeň prvá rozcvička
Budúcu stredu o 10:00 test pre pokročilých

Prednáška 2

Premenné

Tradičný preškrtnutý domček

Spomeňme si na program na vykresľovanie domčeka z minulej prednášky:

#include "../SVGdraw.h"

int main(void) {
    SVGdraw drawing(200, 300, "domcek1.svg");

    drawing.drawRectangle(50, 150, 100, 100);

    drawing.drawLine(50, 250, 150, 150);
    drawing.drawLine(50, 150, 150, 250);

    drawing.drawLine(50, 150, 100, 50);
    drawing.drawLine(150, 150, 100, 50);

    drawing.finish();
}

Ak by sme v ňom chceli zmeniť napríklad výšku domčeka, museli by sme pomeniť veľa súradníc v celom programe. Navyše keď vidíme v programe nejaké číslo, napr. 250, nevieme, ako sme k nemu prišli.

Program na kreslenie domčeka teraz prepíšeme tak, aby sme polohu a veľkosť domčeka mali zapísané symbolicky a mohli ich meniť na jednom mieste.

#include "../SVGdraw.h"

int main(void) {
    /* x a y sú súradnice ľavého horného rohu domčeka,
     * width a height sú jeho šírka a dĺžka,
     * roof je výška strechy. */
    int x = 50;
    int y = 150;
    int width = 100;
    int height = 100;
    int roof = 100;

    /* Vytvor obrázok s rozmermi 200x300 pixelov a 
     * ulož ho do súboru domcek1.svg*/
    SVGdraw drawing(200, 300, "domcek1.svg");

    /* Nakresli obdĺžnik (štvorec) s ľavým horným rohom v 50, 150
     * a šírkou aj dĺžkou 100. */
    drawing.drawRectangle(x, y, width, height);

    /* Prečiarkni štvorec dvomi čiarami po uhlopriečke. */
    drawing.drawLine(x, y+height, x+width, y);
    drawing.drawLine(x, y, x+width, y+height);

    /* Nakresli strechu ako dve čiary. */
    drawing.drawLine(x, y, x+width/2, y-roof);
    drawing.drawLine(x+width, y, x+width/2, y-roof);

    /* Ukonči vypisovanie obrázka. */
    drawing.finish();
}

Symbolickým hodnotám x,y,width,height,roof sa hovorí premenné.

Premmená je určité vyhradené miesto v pamäti počítača, ku ktorému v programe pristupujeme pod určitým názvom.
Do tejto pamäti si môžeme zapísať hodnotu a neskôr ju použiť.

Príkaz int x=100; vytvorí novú premennú a uloží do nej hodnotu 100.
Každá premenná má určitý typ, ktorý určuje, aké hodnoty do nej môžeme ukladať.
Tieto premenné majú typ int, čo je skratka zo slova integer, celé číslo.

Domček s height=200, roof=50

Ak v programe premenným priradíme iné čísla, môžeme vytvárať domčeky, ktorú budú vyššie alebo širšie, alebo budú mať strechu inej výšky, napr:

    int x = 100;
    int y = 300;
    int width = 100;
    int height = 200;
    int roof = 50;

Príkaz int x=100; vieme rozpísať aj na dva príkazy int x; x=100;. Prvý z nich vytvorí premennú x, ktorá teraz bude mať nejakú ľubovoľnú hodnotu a druhý túto počiatočnú hodnotu zmení na 100.

Cvičenie: v programe sa opakuje vzorec na výpočet x-ovej súradnice vrcholu strechy. Spočítajte ho iba raz a uložte do premennej middle

Textový výpis a načítanie

Vieme už vypísať niečo na obrazovku (výstup - output) a podobne môžeme aj čítať, čo nám používateľ napíše na klávesnici (vstup - input). Takéto zadané hodnoty s tiež uložíme v premenných, aby sme s nimi mohli ďalej pracovať.

Nasledujúci program od užívateľa vypýta dve čísla a vypíše ich súčet.

#include <iostream>
using namespace std;

int main(void) {
    int x, y;

    cout << "Please enter the first number: ";
    cin >> x;
    cout << "Please enter the second number: ";
    cin >> y;

    int result = x + y;
    cout << x << "+" << y << "=" << result << endl;
}

Tu je príklad behu programu, keď užívateľ zadal čísla 10 a 3:

Please enter the first number: 10
Please enter the second number: 3
10+3=13

Tento program používa na vstup a výstup príkazy z knižnice iostream a teda do hlavičky programu dáme #include <iostream> a using namespace std;
Program najskôr vytvorí dve premenné x a y typu int (a nepriradzuje im zatiaľ žiadne hodnoty)
Potom príkazom cout vypíše text "Please enter the first number: " aby užívateľ vedel, čo má robiť.
Potom pomocou príkazu cin načíta číslo od používateľa do premennej x
To isté opakuje pre premennú y
Potom vytvorí novú premennú result a uloží do nej súčet x a y.
Nakoniec vypíše výsledok aj s výrazom, ktorý sme počítali, pomocou príkazu cout.

Viac o príkaze cout

Pomocou cout vypisujeme na konzolu, t.j. textovú obrazovku
To, čo chceme vypísať pošleme na cout pomocou šípky <<
cout << endl; vypíše koniec riadku
Môžeme naraz vypísať aj viac vecí oddelených šípkami <<
- Napr. cout << x << "+" << y << "=" << result << endl; vypíše najskôr obsah premennej x (napr. hodnotu 10), potom znamieko plus (ktoré máme v úvodzovkách), potom obsah premennej y, potom znamienko rovnosti, potom obsah premennej result a nakoniec koniec riadku.

Viac o príkaze cin

Pomocu cin načítavame z konzoly údaje od užívateľa
Tieto údaje pošleme do premenných pomocou šípky >>
Opäť môžeme načítať aj viac vecí naraz, napr. nasledovný úryvok si vypýta obe čísla naraz a uloží ich do premenných x a y

   cout << "Please enter two numbers separated by space: ";
   cin >> x >> y;

Pozor, cin nekontroluje, že užívateľ zadáva rozumné hodnoty. Čo sa stane, ak namiesto čísla zadá nejaké písmená a podobne?

Výrazy

Pri využívaní premenných by sme si mali niečo povedať aj o výrazoch a ich vyhodnocovaní. Na vytváranie výrazov v programe môžeme používať aritmetické a logické výrazy, zátvorky, čísla, konštanty a premenné.

Premenné

Pre začiatok budeme pracovať s premennými typu int a double.
Premenná typu int reprezentuje celé číslo.
Premenná typu double reprezentuje reálne číslo.
Ich rozsah je však obmedzený.
- Typ int väčšinou zaberá 4 bajty (32 bitov) pamäte a vie ukladať čísla z intervalu <-2 147 483 648, +2 147 483 647>
- Typ double väčšinou zaberá 8 bajtov a je uložený vo formáte s pohyblivou rádovou čiarkou, t.j. vo forme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle z\cdot a\cdot 2^b} , kde z je znamienko, a je reálne číslo z intervalu <1,2) (mantisa) a b je celé číslo (exponent). Na uloženie mantisy sa používa 52 bitov a na uloženie exponentu 11 bitov. Vieme teda spracovávať zhruba čísla v rozsahu od Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^{-300}} po Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^{300}} s presnosťou na 15 až 16 platných cifier.
Keď priradíme hodnotu typu double do hodnoty typu int, dôjde k jej zaokrúhleniu (nadol pri kladných číslach, nahor pri záporných).

Aritmetické výrazy

+, -, * (násobenie), / (delenie)
- delenie celočíselných premenných vráti dolnú celú časť podielu, napr. 5/3 je 1 (pre záporné čísla to môže byť horná celá časť)
% je modulo, napr. 5%3 bude 2, lebo 5 má zvyšok 2 po delení 3
ďalšie matematické funkcie vyžadujú #include <cmath> v hlavičke programu
- napríklad cos(x), sin(x), tan(x) (tangens), acos(x) (arkus kosínus), exp(x) (Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle e^x} ), log(x) (prirodzený logaritmus), pow(x,y) (Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^y} ), sqrt(x) (odmocnina), abs(x) (absolútna hodnota), floor(x) (dolná celá časť)
- pozri tiež zoznam tu

Skratky: Ak chceme zvýšiť hodnotu premennej x o 1, môžeme použiť niektorý z nasledujúcich spôsobov:

x = x+1;
x++;
x += 1;

Podobne ako ++ existuje aj --, podobne ako += existuje aj -=, *= atď

Konštanty

Celočíselné konštanty, ako napríklad 0, 1, 100, -5, majú typ int
Konštanty s desatinnou bodkou, ako napríklad 1.5, 1.0, 3.13, -0.5 majú typ double. Môžeme tiež používať semilogaritmický zápis typu 1.5e3, čo znamená Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 1.5\cdot 10^3} , t.j. 1500.

Logické konštanty a výrazy

Logické konštanty: true (1) a false (0)
Logické výrazy dávajú ako výsledok pravdivostnú hodnotu -- logickú konštantu
- == (rovnosť), != (nerovnosť), <, <=
- && (logický AND), || (logický OR), ! (logický NOT)

Vyhodnocovanie výrazov

Výrazy sa vyhodnocujú s preferenciou podľa nasledovnej tabuľky. Výrazy v jednom riadku tabuľky majú rovnakú prednosť a vyhodnocujú sa väčšinou zľava doprava, okrem !,++,-- a priradenia.

++, --, logický NOT
*, /, %
+, -
<, >, <=, >=
==, !=
&& (logický AND)
|| (logický OR)
priradenie

Poradie vyhodnocovania môžeme meniť zátvorkami, napr. 4*(5-3)

Viac o operátoroch v C++ nájdete napríklad tu.

Podmienka (if)

Niekedy chceme vykonať určité príkazy len ak sú splnené nejaké podmienky. To nám umožňuje príkaz podmienky if.

Nasledujúci program si vypýta od užívateľa číslo a vypíše, či je toto číslo párne (even) alebo nepárne (odd).

 #include <iostream>
using namespace std;

int main(void) {
    int x;
    cout << "Please enter some number: ";
    cin >> x;

    if (x % 2 == 0) {
        cout << "Number " << x << " is even." << endl;
    } else {
        cout << "Number " << x << " is odd." << endl;
    }

}

Tu je príklad dvoch behov programu:

Please enter some number: 10
Number 10 is even.

Please enter some number: 3
Number 3 is odd.

Ako vidíme, za príkazom if je zátvorka s podmienkou. V našom príklade podmienka je x % 2 == 0. Zoberieme teda hodnotu x, pomocou operátora % zistíme zvyšok po delení 0 a pomocou dvoch rovnítok == testujeme, či je tento zvyšok rovný nule.
Ak je podmienka v zátvorke splnená (t.j. ak je zvyšok rovný nule), vykonáme príkazy v zloženej zátvorke za príkazom if.
Ak podmienka nie je splnená (t.j. ak zvyšok nie je rovný nule), vykonáme príkazy v zloženej zátvorke za slovom else
Časť else {...} je možné vynechať, ak nechceme vykonávať žiadne príkazy.
Nateraz píšeme zátvorky { a } za if aj za else. Ak za nimi nasleduje iba jeden príkaz, môžeme ich vynechať, ľahko to však vedie k chybám, preto je lepšie ich vždy použiť.

Vnorené podmienky

Pritom príkazy if môžeme navzájom vnárať, čím vzniknú vcelku komplikované výrazy.

Načítaj čislo a zisti, či je kladné, záporné alebo nula.

#include <iostream>
using namespace std;

int main(void) {
    int x;
    cout << "Please enter some number: ";
    cin >> x;

    if (x == 0) {
        cout << "Null" << endl;
    } else {
        if (x > 0) {
            cout << "Positive" << endl;
        } else {
            cout << "Negative" << endl;
        }
    }

}

Cvičenie: vypíšte, koľko z čísel 2,3,5 delí zadané číslo x. Napr.

Zadajte cislo: 6
Pocet delitelov z mnoziny {2,3,5}: 2

Zadajte cislo: 60
Pocet delitelov z mnoziny {2,3,5}: 3

Zadajte cislo: 7
Pocet delitelov z mnoziny {2,3,5}: 0

Upozornenie

Častá chyba, ktorá sa vyskytuje pri podmienke je použitie priradenia namiesto porovnania. Keby sme napísali

if (x=0) cout << “Null” << endl;

tak program do premennej x priradí nulu, ktorá sa premení na logické false pre účely vyhodnotenia podmienky.

Ďalšia bežná chyba je zabudnutie zložených zátvoriek

   if (x==0) cout << “Null”; cout << endl;

Tento program vykoná cout << endl vždy, nezávisle od podmienky. V prípade, že chceme vykonať v podmienke viacero príkazov, nesmieme zabudnúť ich uzátvorkovať:

   if (x==0) { cout << “Null”; cout << endl; }

Cyklus (for)

Teraz si ukážeme príkaz for, ktorý nám umožňuje opakovať viackrát nejakú skupinu príkazov.

Na úvod trochu motivácie. Ako by ste napísali nasledovné jednoduché programy?

Vypíšte čísla od 0 do 9. A následne od 0 do 24. (pre vytrvalých od 0 do 99)
Vykreslite pravidelný štvoruholník. Šesťuholník? Devätnásťuholník?

Vypisovanie čísiel

Nasledujúci program vypíše čísla 0 až 9 oddelené medzerami bez toho, aby sme ich niekde v programe explicitne vymenovali.

#include <iostream>
using namespace std;

int main(void) {
    for (int i = 0; i < 10; i++) {
        cout << " " << i;
    }
    cout << endl;
}

Tu je výstup programu.

0 1 2 3 4 5 6 7 8 9

Ak by sme v programe číslo 10 zmenili napr. na 25, vypíše čísla 0 do 24.

Novou črtou tohto programu je príkaz for pre cyklus: for (int i = 0; i < 10; i++)
Cyklus nám umožňuje opakovať určitú časť programu viackrát.
V zátvorke za for sú tri časti oddelené bodkočiarkami.
- Príkaz int i = 0 vytvorí novú celočíselnú premenú i a priradí jej hodnotu 0.
- Podmienka i < 10 určuje dokedy sa má cyklus opakovať, t.j. kým hodnota i je menšia ako 10.
- Príkaz i++ hovorí, že v každom kroku sa má premenná i zvýšiť o jedna.
Medzi zložené zátvorky { a } môžeme dať jeden alebo viac príkazov, ktoré sa budú opakovať pre rôzne hodnoty premennej i.
- V našom príklade máme vo vnútri cyklu iba príkaz cout << " " << i;, ktorý vypíše medzeru a hodnotu premennej i.
Po skončení cyklu sa pokračuje príkazmi za končiacou zloženou zátvorkou, v našom prípade vypíšeme ešte koniec riadku.
Všimnite si, že náš program obsahuje dve sady zložených zátvoriek vnorených v sebe: jedna ohraničuje celý program, jedna ohraničuje príkazy, ktorá sa robia vo vnútri cyklu.

O presnom fungovaní príkazu for si povieme viac neskôr, ale teraz sa pozrime, čo spraví jednoduchá zmena v tomto príkaze:

for (int i = 1; i <= 10; i++) {

Počiatočnú príkaz sme zmenili z int i = 0 na int i = 1, premenná i teda začne s hodnotou 1, nie 0. Cyklus môže začať od ľubovoľnej hodnoty (napríklad aj zápornej)
Podmienku ukončenia sme zmenili z i < 10 na i <= 10, t.j. cyklus sa opakuje kým je hodnota premennej i menšia alebo rovná 10 (to isté by sme dosiahli aj pomocou i < 11)
Program teda vypíše čísla od 1 po 10:

 1 2 3 4 5 6 7 8 9 10

Vykreslenie náhodných kruhov

Nasledujúci program vykreslí na obrazovku náhodne rozmiestnené kruhy.

#include "../SVGdraw.h"
#include <cstdlib>
#include <ctime>

int main(void) {
    int size = 300; /* veľkosť obrázku */
    int count = 30; /* počet kruhov */
    int diameter = 10; /* priemer kruhu */

    /* inicializácia generátora pseudonáhodných čísel */
    srand(time(NULL));

    /* Vytvor obrázok s rozmermi 200x300 pixelov a 
     * ulož ho do súboru domcek1.svg*/
    SVGdraw drawing(size, size, "kruhy1.svg");
    
    for (int i = 0; i < count; i++) {
        /* vykresli kruh s priemerom diameter na náhodné miesto */
        drawing.drawEllipse(rand() % size, rand() % size, diameter, diameter);
    }
 
    /* Ukonči vypisovanie obrázka. */
    drawing.finish();
}

Program využíva príkaz rand(), ktorý generuje pseudonáhodné celé čísla. (Nie sú v skutočnosti náhodné, lebo ide o pevne definovanú matematickú postupnosť, ktorá však má mnohé vlastnosti náhodných čísel).
- Výsledkom rand() je celé nezáporné číslo medzi 0 a nejakou veľkou konštantou.
- rand() % size je číslo medzi 0 a size-1
- vygenerujeme dve také čísla a použijeme ich ako súradnice kruhu (presnejšie ľavého horného rohu štvorca opísaného kruhu)
Príkaz srand inicializuje generátor pseudonáhodných čísel na určitú hodnotu, my použijeme aktuálny čas.
Potrebujeme knižnice cstdlib a ctime.

Skúsme pred príkaz drawing.drawEllipse dať ešte príkaz drawing.setFillColor, ktorý nastaví farbu výplne kruhu. Túto farbu chceme tiež nastaviť na náhodnú hodnotu, t.j. vygenerujeme tri náhodné čísla pre červenú, zelenú a modrú zložku tejto farby. Tieto čísla majú byť medzi 0 a 255.

/* nastav náhodnú farbu */
drawing.setFillColor(rand() % 256, rand() % 256, rand() % 256);

Cvičenie: čo by sa zmenilo, keby sme príkaz drawing.setFillColor dali pred for-cyklus?

Cvičenie: nastavme aj priemer kruhu ako náhodné číslo od 0 do 19. Čo ak chceme priemer od 10 do 19?

Organizačné poznámky

Dnes zverejnenie DÚ1
V piatok 22:00 termín odovzdania DÚ0
Budúci týždeň na cvičeniach prvá rozcvička - kreslenie so SVGdraw
Cvičenia vo štvrtok sú NEPOVINNÉ, t.j. nie je na nich rozcvička
Budúcu stredu o 10:00 test pre pokročilých, prihlasovanie do tohto piatku

Cvičenia 1

Cieľom prvých cvičení je vyskúšať si prostredie Netbeans a jednoduché úpravy textových aj grafických programov z prednášky. Podobné programy budete písať budúci týždeň na rozcvičke, takže doporučujeme si priniesť papier s poznámkami z prvej prednášky.

Príklad 1

Prihláste sa na počítač a spustite Netbeans podľa návodu tu
Vytvorte nový projekt a skopírujte si tam Hello world program z prvej prednášky
Skúste ho skompilovať a spustiť.
Zmodifikujte ho tak, aby vypisoval slovenskú hlášku Ahoj svet! a opäť ho skompilujte a spustite.

Príklad 2

Prihláste sa na odovzdávací server, zmeňte si heslo, vyriešte a odovzdajte nultú domácu úlohu.

Príklad 3

Vytvorte nový projekt s programom na vykreslenie domčeka z prvej prednášky
- Postupujte podľa návodu tu
- Stiahnite si grafickú knižnicu SVGdraw a správne ju umiestnite
- Nezabudnite pridať súbory knižnice do projektu
Program skompilujte a spustite
Nájdite vytvorený obrázok a pozrite si ho
Zmodifikujte ho tak, aby nad domčekom v hornej časti obrázku bol zelený nápis Domcek

Príklad 4

Nakreslite korytnačou grafikou jedným ťahom obrázok napravo. Všetky malé trojuholníky na obrázku sú rovnostranné s dĺžkou hrany 100, veľký trojuholník má teda dĺžku hrany 200. Pripomíname, že v rovnostrannom trojuholníku majú vnútorné uhly 60 stupňov.

Vytvorený obrázok si pozrite programom Firefox, aby ste videli animáciu korytnačky

Prednáška 3

Doteraz sme videli:

Vypisovanie a načítavanie v textovom režime
Vykresľovanie pomocou grafickej knižnice SVGdraw
Aritmetické a logické výrazy, premenné typu int a double
Podmienku if
Cyklus for

Dnes:

Ďalšie príklady na cykly a podmienky, zopár menších noviniek.

Viac príkladov na cyklus for

Výpočet faktoriálu

Tento program si od užívateľa vypýta číslo n a spočíta n!, t.j. súčin celých čísel od 1 po n.

#include <iostream>
using namespace std;

int main(void) {
    int n;

    cout << "Please enter n: ";
    cin >> n;

    int result = 1;
    for (int i = 1; i <= n; i++) {
        result = result * i;
    }
    cout << n << "!=" << result << endl;
}

Tu je príklad behu programu pre n=4 (1*2*3*4=24)

Please enter n: 4
4!=24

Program používa premennú result, v ktorej sa ukladá dočasný výsledok. Na začiatok ju nastavíme na 1 a postupne ju násobíme číslami 1, 2, ..., n.
Riadok result = result * i; zoberie pôvodnú hodnotu premennej result, vynásobí ju hodnotou premennej i (t.j. jedným z čísel 1, 2, ..., n) a výsledok uloží naspäť do premennej result (prepíše pôvodnú hodnotu). To isté sa dá napísať ako result *= i;

Krokovanie programu

Skúsme si odkrokovať, ako sa budú postupne meniť hodnoty premenných počas behu programu
Krokovanie programu a vypisovanie hodnôt premenných je možné robiť v prostredí Netbeans, mali by ste však byť schopní to robiť aj ručne, lebo tým lepšie pochopíte, ako program pracuje.
Krokovanie v prostredí Netbeans:
- Klikneme pravým na meno projeku v záložke Projects, zvolíme Step into
- Tým sa naštaruje a hneď aj zastaví náš program, ďalej sa môžeme púšťať program riadok po riadku ikonkou Step Over (F8)
- V dolnej časti okna v záložke Variables vidíme hodnoty vybraných premenných, ďalšie si môžeme ručne pridať

Int má obmedzený rozsah

Funkcia n! veľmi rýchlo rastie a už pre n=13 sa výsledok nezmestí do premennej typu int. Dostávame nezmyselné hodnoty:

12!=479001600
13!=1932053504
14!=1278945280
15!=2004310016
16!=2004189184
17!=-288522240

Správne hodnoty sú:

12!=479001600
13!=6227020800
14!=87178291200
15!=1307674368000
16!=20922789888000
17!=355687428096000

Cvičenie: Prepíšme program na počítanie faktoriálu tak, aby vypísal aj faktoriál ako súčin čísel, napríklad

Please enter n: 4
4! = 1*2*3*4 = 24

Vypisovanie deliteľov: podmienka v cykle

Nasledujúci program načíta číslo od užívateľa a vypíše zoznam jeho deliteľov.

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Please enter some number: ";
    cin >> n;

    cout << "Divisors of " << n << ":";
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            cout << " " << i;
        }
    }
    cout << endl;
}

Beh programu:

Please enter some number: 12
Divisors of 12: 1 2 3 4 6 12

Malá odbočka: úprava a čitateľnosť programov

Okrem počítača budú váš program čítať aj ľudia: vy sami, keď v ňom potrebujete nájsť chybu alebo ho v budúcnosti rozširovať, vaši kolegovia vo firme, učitelia v škole. Preto treba programy písať tak, aby boli nielen správne, ale aj prehľadné a ľahko pochopiteľné. Tu sú zásady, ktoré takejto čitateľnosti pomáhajú:

Odsadzovanie: príkazy vykonávané v cykle alebo podmienke (medzi { a }) odsaďte o niekoľko pozícií doprava. Pri vnorených cykloch a podmienkach odsaďte každú ďalšiu úroveň viac.
- V Netbeans sa dá odsadzovanie napraviť na vybranom texte pomocou položky menu Source->Format
Medzery a voľné riadky: prehľadnosť zvýšite, ak oddelíte ucelené časti programu voľným riadkom. V zložitejších výrazoch doporučujeme vkladať medzery okolo operátorov:
- for(int i=0;i<count;i++){
- for (int i = 0; i < count; i++) {
Dĺžka riadku: doporučujeme sa vyhýbať sa dlhým riadkom nad 80 znakov. Sú problémy s ich tlačením alebo zobrazovaním v menších oknách, aj na veľkom monitore namáhajú čitateľa. V prípade potreby je možné dlhšiu podmenku alebo iný výraz rozdeliť na viac riadkov.
Názvy premenných: je vhodné používať názvy premenných, ktoré vyjadrujú ich obsah (po anglicky príp. slovensky). Pri premenných v kratších programoch, alebo ktoré sa používajú len lokálne v kratšom kúsku programu môžete použiť aj krátke zaužívané názvy, napr. i a j pre premenné v cykloch, n pre počet, a pre pole.
Komentáre: význam jednotlivých úsekov kódu je dobré popísať v komentároch.

Pri známkovaní budeme brať do úvahy aj prehľadnosť vašich programov.

Cyklus while

Okrem cyklu for môžeme použiť aj cyklus while, ktorý vyzerá nasledovne:

while (podmienka) { 
  príkaz; 
}

Čítame: kým je splnená podmienka vykonávaj príkaz. Podrobnejšie:

podmienka je výraz, ktorý sa najskôr vyhodnotí:
- ak je jeho hodnota logická nepravda, cyklus je ukončený a program pokračuje ďalším príkazom za while{...}
- ak je jeho hodnota logická pravda, vykoná sa príkaz a celý cyklus sa opäť opakuje.

Úroky v banke

Na začiatku každého roku uložíme 1000 EUR na úrokovú vkladnú knižku s ročným úrokom 5%. Zistite, za koľko rokov naše úspory dosiahnu sumu aspoň 20 000 EUR.

Vieme určite, že budeme musieť peniaze vkladať niekoľko rokov. Problém je v tom, že dopredu nevieme povedať koľko, pretože počet rokov je vlastne výstupom programu. Neformálne by sme algoritmus na vyriešenie mohli popísať takto:

Založ si účet v banke (zatiaľ šetríš nula rokov)
Kým nemáš na začiatku roka našetrené 20 000 EUR opakuj:
- Vlož čiastku a čakaj na nový rok, kým sa zúročia

Potrebujeme cyklus, ktorý sa bude vykonávať, kým platí nejaká podmienka - práve na to je vhodný while cyklus. Pomocou neho zapíšeme algoritmus nasledovne:

#include <iostream>
using namespace std;

int main(void) {
    double ucet = 0;
    int rok = 0;

    while (ucet < 20000) {
        ucet = (ucet + 1000) * 1.05;
        rok++;   /* to isté ako rok = rok + 1 */
        cout << "Na konci roku " << rok << " máme na účte " << ucet << " EUR" << endl;
    }
}

Na konci roku 1 máme na účte 1050 EUR
Na konci roku 2 máme na účte 2152.5 EUR
Na konci roku 3 máme na účte 3310.12 EUR
Na konci roku 4 máme na účte 4525.63 EUR
Na konci roku 5 máme na účte 5801.91 EUR
Na konci roku 6 máme na účte 7142.01 EUR
Na konci roku 7 máme na účte 8549.11 EUR
Na konci roku 8 máme na účte 10026.6 EUR
Na konci roku 9 máme na účte 11577.9 EUR
Na konci roku 10 máme na účte 13206.8 EUR
Na konci roku 11 máme na účte 14917.1 EUR
Na konci roku 12 máme na účte 16713 EUR
Na konci roku 13 máme na účte 18598.6 EUR
Na konci roku 14 máme na účte 20578.6 EUR

Euklidov algoritmus na nájdenie najväčšieho spoločného deliteľa

Jeden z najstarších dodnes používaných algoritmov, Euklides ho popísal v svom diele Základy, cca 300 pred Kr.
Máme dané dve kladné celé čísla a a b a chceme nájsť najväčšie číslo d, ktoré delí a aj b.
Skratka nsd(a,b), po anglicky gcd(a,b) (greatest common divisor)

Príklad:
- Delitele 12: 1, 2, 3, 4, 6, 12
- Delitele 8: 1, 2, 4, 8
- Spoločné delitele 8 a 12: 1, 2, 4
- gcd(8,12)=4

Lema: pre všetky kladné celé čísla a a b platí: gcd(a,b) = gcd(b, a mod b)
- nech Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x = a \bmod b, y = \lfloor a/b\rfloor}
- nech A je množina spoločných deliteľov a a b, B je množina spoločných deliteľov b a x
- ukážeme, že A=B (a teda aj Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle \max A = \max B} )
- a = yb + x a preto každý deliteľ b a x delí aj a, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle B\subseteq A}
- taktiež x = a - yb a preto každý deliteľ a aj b delí aj x, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle A\subseteq B}

#include <iostream>
using namespace std;

int main(void) {
    int a, b;
    cout << "Enter two positive integers a and b: ";
    cin >> a >> b;
    while(b != 0) {
        int x = a % b;
        a = b;
        b = x;
    }
    cout << "Their gcd: " << a << endl;
}

Príklad behu programu:

Enter two positive integers a and b: 30 8
Their gcd: 2

Tento výpočet prešiel cez dvojice:

Nekonečný cyklus

while (true) {
 prikaz;
}

Opakuje príkaz donekonečna (kým program nezastavíme).

Napríklad môžeme donekonečna niečo vypisovať na konzolu.

#include <iostream>
using namespace std;

int main(void) {
    while (true) {
      cout << "Hello world!" << endl;
    }
}

Hra hádaj číslo

V nasledujúcom programe si počítač "myslí číslo" od 1 do 100 a užívateľ háda, o ktoré číslo ide.

Program používa premennú typu bool, do ktorej môžeme priraďovať logické hodnoty true alebo false.

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main(void) {
    /* vygenerujeme náhodné číslo medzi 1 a 100 */
    srand(time(NULL));
    int number = rand() % 100 + 1;

    /* Pamätáme si, či sme už uhádli alebo nie. */
    bool guessed = false;
    cout << "Guess a number between 1 and 100: ";
    /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu
       odpoveď. */
    while (!guessed) {
        int guess;
        cin >> guess;
        /* Vyhodnotíme odpoveď. */
        if (guess < number) {
            cout << "Too low, try again: ";
        } else if (guess > number) {
            cout << "Too high, try again: ";
        } else if (guess == number) {
            guessed = true;
            cout << "Correct guess" << endl;
        }
    }
}

Príklad priebehu programu:

Guess a number between 1 and 100: 50
Too low, try again: 75
Too high, try again: 63
Too low, try again: 69
Too high, try again: 66
Too low, try again: 67
Correct guess

Príkazy break a continue (používať s mierou)

Príkaz break: skončí sa cyklus, v ktorom práve sme, pokračuje sa prvým príkazom za cyklom.
Príkaz continue: ide na ďalšiu iteráciu cyklu, nevykoná zvyšok tela cyklu.

Používať s mierou, robia program menej prehľadný, ľahko zavlečú chyby.

Program uvedený vyššie môžeme prepísať bez boolovskej premennej s použitím nekonečného cyklu, z ktorého ale vyskočíme príkazom break, keď užívateľ uhádne.

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

int main(void) {
    /* vygenerujeme náhodné číslo medzi 1 a 100 */
    srand(time(NULL));
    int number = rand() % 100 + 1;

    cout << "Guess a number between 1 and 100: ";
    /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu
       odpoveď. */
    while (true) {
        int guess;
        cin >> guess;
        /* Vyhodnotíme odpoveď. */
        if (guess < number) {
            cout << "Too low, try again: ";
        } else if (guess > number) {
            cout << "Too high, try again: ";
        } else if (guess == number) {
            cout << "Correct guess" << endl;
            break;
        }
    }
}

Späť k cyklu for

Cyklus for má tvar

for(prikaz1; podmienka; prikaz2) {
    prikaz3;
}

Je ekvivalentný nasledujúcemu príkazu while:

prikaz1;
while(podmienka) {
    prikaz3;
    prikaz2;
}

Napríklad, nasledujúce kúsky kódu oba vypisujú čísla 0 až 9:

for (int i = 0; i < 10; i++) {
     cout << " " << i;
}

int i = 0;
while(i < 10) {
     cout << " " << i;
     i++;
}

Cyklus for spravidla používame, ak má náš cyklus krátky a jednoduchý iterátor (prikaz2) a jednoduchú podmienku. V opačnom prípade väčšinou používame cyklus while.

Ešte vypisovanie deliteľov

Ak chceme vypísať deliteľov od najväčších, stačí prepísať for cyklus:

od najmenších: for (int i = 1; i <= n; i++) {
od najväčších: for (int i = n; i > 0; i--) {

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Please enter some number: ";
    cin >> n;

    cout << "Divisors of " << n << ":";
    for (int i = n; i > 0; i--) {
        if (n % i == 0) {
            cout << " " << i;
        }
    }
    cout << endl;
}

Príklad behu programu:

Please enter some number: 30
Divisors of 30: 30 15 10 6 5 3 2 1

Zrýchlime program na vypisovanie deliteľov: ak i je deliteľ n, aj n/i je deliteľ, môžeme ho rovno vypísať. Aspoň jeden z tejto dvojice je najviac odmocnina z n.

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Please enter some number: ";
    cin >> n;

    cout << "Divisors of " << n << ":";

    for(int i=1; i*i<=n; i++) {
        if (n % i == 0) {
            int j = n / i;
            cout << " " << i << " " << j;
        }
    }
    cout << endl;
}

Cvičenie: Tento program nefunguje celkom správne, občas vypíše nejaké číslo dvakrát. Kedy? Ako ho vieme opraviť?

Pomalší program, ktorý skúša všetky čísla po n trvá pre n=1234567890 na mojom počítači 4.5s. Program, ktorý ide iba po odmocninu trvá 0.0002s.

Vnorené cykly

Vykreslime šachovnicu s n x n štvorčekmi, ktoré sú striedavo čierne a žlté.

Potrebujeme na to dva vnorené cykly, jeden pôjde cez riadky šachovnice, druhý pre stĺpce.
Ak row + column je párne, kreslíme čierny štvorec, inak kreslíme žltý.

#include "../SVGdraw.h"

int main(void) {
    int n = 8; /* počet štvorcov v riadku a stĺpci*/
    int square = 20; /* veľkosť jedného štvorca */
    int size = n * square; /* veľkosť obrázku */

    SVGdraw drawing(size, size, "sachovnica.svg");

    for (int row = 0; row < n; row++) {
        for (int column = 0; column < n; column++) {
            if ((row + column) % 2 == 0) {
                drawing.setFillColor("black");
            } else {
                drawing.setFillColor("yellow");
            }
            drawing.drawRectangle(column * square, row * square,
                                  square, square);
        }
    }
    drawing.finish();
}

To isté, ale najskôr vykreslíme veľký žltý štvorec, potom do neho vkresľujeme malé čierne štvorčeky.

V cykle pre stĺpce preskakujeme každý druhý štvorec, pričom ak row je párny, začíname od 0, ak je nepárny, začíname od 1
- for (int column = row % 2; column < n; column += 2) {
- príkaz column += 2 je to isté ako column = column + 2

#include "../SVGdraw.h"

int main(void) {
    int n = 8; /* počet štvorcov v riadku a stĺpci*/
    int square = 20; /* veľkosť jedného štvorca */
    int size = n * square; /* veľkosť obrázku */

    SVGdraw drawing(size, size, "sachovnica.svg");

    /* veľký žltý štvorec */
    drawing.setFillColor("yellow");
    drawing.drawRectangle(0,0,size,size);

    /* nastavíme farbu na čiernu */
    drawing.setFillColor("black");
    
    for (int row = 0; row < n; row++) {
        for (int column = row % 2; column < n; column += 2) {
            drawing.drawRectangle(column * square, row * square,
                                  square, square);
        }
    }
    drawing.finish();
}

Zhrnutie

Videli sme niekoľko príkladov využitia cyklov for a while.
Cyklus for je možné zapísať ako while (a naopak).
Logické hodnoty true a false vieme ukladať do premenných typu bool.
Z cyklu vieme vyskočiť príkazom break, prejsť na ďalšiu iteráciu príkazom continue. Používať s mierou.
Euklidov algoritmus rýchlo nájde najväčšieho spoločného deliteľa dvoch čísel.
Dôležitá je prehľadná úprava programov a názvy premenných súvisiace s ich obsahom.
Netbeans umožňuje krokovať program, mali by ste to však vedieť robiť aj ručne.

Organizačné poznámky

Tento týždeň na cvičeniach prvá rozcvička
Zajtra prednáška nebude (imatrikulácia)
V stredu o 10:00 v M-213 test pre pokročilých
Na stránke zadania DÚ1, riešte do piatku 4.10.
V priebehu týždňa pribudnú zadania DÚ2 a PDÚ1

Cvičenia 2

Úlohou dnešného cvičenia je precvičiť si logické a aritmetické výrazy, podmienky a jednoduché použitie cyklu for.

Nasledujúce dva úryvky programu robia to isté, pričom prvý používa logický operátor && (and) a druhý používa dva príkazy if:

//Verzia 1:
if(x>0 && y>0) { cout << "Yes!"; }

//Verzia 2:
if(x>0) {
  if(y>0) { cout << "Yes!"; }
}

Podobne nahraďte logické operátory && a || aj v nasledujúcich príkazoch:

if(x>0 || y>0) { cout << "Yes!"; }
if (x>0 || (x<0 && y<0)) { cout << "Yes!"; }
if (x<0 && (y<0 || z<0)) { cout << "Yes!"; }

Nech x je nejaký logický výraz. Čomu sa rovnajú nasledovné výrazy?

x && true 
x && false 
x || true 
x || false
x && x
x || x 
x && !x
x || !x
x == true 
x == false

Napíšte program, ktorý načíta dve čísla a vypíše to väčšie z nich.

Napíšte program, ktorý korytnačou grafikou vykreslí pravidelný n-uholník. V programe si zadefinujte a použite nasledujúce premenné

    int size = 300; /* veľkosť obrázku */
    int length = 200; /* dĺžka strany */
    int n = 4; /* počet strán */

Vyskúšajte meniť hodnoty premenných a pozrite si výsledok.

Napíšte program, ktorý načíta tri celé čísla a vypíše, či môžu byť stranami jedného trojuholníka.

Napíšte program, ktorý vypíše tabuľku druhých mocnín čísel 1,2,...,n. Výstup bude mať takúto formu:

1 squared is 1
2 squared is 4
3 squared is 9
...

Napíšte program, ktorý načíta štyri celé čísla a,b,c,d, ktoré predstavujú dva uzavreté intervaly [a,b] a [c,d]. Program vypíše tú z nasledujúcich viet, ktorá pre ne platí:

   Intervaly su disjunktne (maju prazdny prienik).
   Jeden z intervalov je podmnozinou druheho.
   Intervaly sa pretinaju, ale ziaden nie je podmnozinou druheho.

Napíšte program, ktorý načíta dĺžku základne a výšku rovnoramenného trojuholníka a vykreslí ho pomocou drawLine. Veľkosť obrázku môžete zvoliť pevne 300x300 a horný vrchol trojuholníka (150,20).
- Prepíšte predchádzajúci program, aby používal korytnačiu grafiku. Potrebné dĺžky spočítajte Pytagorovou vetou a uhly spočítajte napr. funkciou atan (arkus tangens). Pozor, atan vracia radiány, treba prepočítať na stupne. Zadefinujte si a použite premennú double pi = 3.1415926536;

Špirála pre n=10

Napíšte program, ktorý vykreslí špirálu korytnačou grafikou ako na obrázku vpravo. Špirála pozostáva z n úsečiek, pričom prvá má dĺžku d a každá ďalšia je o d dlhšia od predchádzajúcej. Čísla n a d sú uložené v premenných. Veľkosť obrázku uložte do ďalšej premennej size. Korytnačka nech začína v strede plochy.

Prednáška 4

Funkcia je skupina príkazov s určitým menom, ktorú môžeme spustiť a vykonať tak určitú akciu alebo vypočítať určitú hodnotu
- Možno ste stretli iné termíny s podobným významom, ako procedúra, metóda, podprogram
V našich programoch sme už používali hotové funkcie
- Napríklad sqrt(x) je funkcia, ktorá nám povie druhú odmocninu čísla x.
- V grafických programoch sme napríklad používali funkciu drawing.drawRectangle(x, y, s, v) z knižnice SVGdraw, ktorá na do obrázku vykreslí obdĺždnik.

Teraz sa pozrieme na to, ako vytvoriť v programe vlastnú funkciu. Doteraz sme vytvorili jedinú funkciu - funkciu main.

Motivačný príklad: Obvod trojuholníka

Chceme napísať program, ktorý načíta súradnice vrcholov trojuholníka a spočíta jeho obvod, tu je príklad jeho behu:

Zadaj suradnice vrcholu A oddelene medzerou: 0 0
Zadaj suradnice vrcholu B oddelene medzerou: 3 0
Zadaj suradnice vrcholu C oddelene medzerou: 0 4
Obvod trojuholnika ABC: 12

Obvod spočítame ako súčet dĺžok jednotlivých strán, v programe teda trikrát opakujeme výpočet dĺžky strany. Pri opakovaní dlhšieho vzorca ľahko spravíme chybu.

#include <iostream>
#include <cmath>
using namespace std;

int main(void) {
    double xa, ya, xb, yb, xc, yc;
    cout << "Zadaj suradnice vrcholu A oddelene medzerou: ";
    cin >> xa >> ya;
    cout << "Zadaj suradnice vrcholu B oddelene medzerou: ";
    cin >> xb >> yb;
    cout << "Zadaj suradnice vrcholu C oddelene medzerou: ";
    cin >> xc >> yc;
    /* spocitaj dlzky stran */
    double da = sqrt((xb - xc) * (xb - xc) + (yb - yc) * (yb - yc));
    double db = sqrt((xa - xc) * (xa - xc) + (ya - yc) * (ya - yc));
    double dc = sqrt((xa - xb) * (xa - xb) + (ya - yb) * (ya - yb));
    cout << "Obvod trojuholnika ABC: " << da + db + dc << endl;
}

Definícia funkcie

Vzorec na výpočet môžeme zapísať ako funkciu:

double dlzka(double x1, double y1, double x2, double y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

Definícia funkcie má nasledovné časti:

Návratová hodnotu funkcie: Naša funkcia vracia dĺžku, teda hodnotu typu double (desatinné číslo). V prípade, že by funkcia nemala vrátiť nič, jej návratová hodnota je typu void. Také sú napríklad funkcie, ktoré niečo vypisujú alebo vykresľujú.
Názov funkcie: zvolíme si ako chceme, podobne ako pri premenných. Vhodné je použiť názov, ktorý vystihuje, čo funkcia počíta, napríklad dlzka
Zoznam parametrov funkcie: V zátvorkách za názvom funkcie je zoznam typov a názvov premenných, ktoré funkcia očakáva. V našom príklade funkcia očakáva súradnice dvoch vrcholov, teda štyri hodnoty typu double. Funkcie môžu mať zoznam parametrov aj prázdny.
Telo funkcie: V zložených zátvorkách za definíciou funkcie je jej vlastný obsah, teda zoznam príkazov, ktoré má funkcia vykonať.
Príkaz return: Vracia hodnotu funkcie.

Program s využitím funkcie

Celý program s funkciou dlzka

vzorec na výpočet dĺžky je teraz iba na jednom mieste

#include <iostream>
#include <cmath>
using namespace std;

double dlzka(double x1, double y1, double x2, double y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

int main(void) {
    double xa, ya, xb, yb, xc, yc;
    cout << "Zadaj suradnice vrcholu A oddelene medzerou: ";
    cin >> xa >> ya;
    cout << "Zadaj suradnice vrcholu B oddelene medzerou: ";
    cin >> xb >> yb;
    cout << "Zadaj suradnice vrcholu C oddelene medzerou: ";
    cin >> xc >> yc;
    /* spocitaj dlzky stran */
    double da = dlzka(xb, yb, xc, yc);
    double db = dlzka(xa, ya, xc, yc);
    double dc = dlzka(xa, ya, xb, yb);
    cout << "Obvod trojuholnika ABC: " << da + db + dc << endl;
}

Funkcia môže obsahovať aj viacero príkazov. V našom príklade môžeme napríklad výpočet rozložiť na tri kroky:

double dlzka(double x1, double y1, double x2, double y2) {
    double dx = x1 - x2;
    double dy = y1 - y2;
    return sqrt(dx * dx + dy * dy);
}

Cvičenie: v Pascale je funkcia sqr(x), ktorá vráti x na druhú. Naprogramujte túto funkciu v jazyku C a použite ju na zjednodušenie funkcie dlzka.

V jazyku C by sme mohli použiť pow(x,2), ale môže byť jednoduchšie zrátať x*x.

Príkaz return

Pri vykonaní príkazu return je funkcia okamžite zastavená a jej výstupná hodnota je výraz za slovom return.
Ak funkcia má niečo vrátiť (jej návratový typ nie je void), musí obsahovať return.
- Príkazov return môže obsahovať viac, ale tak, aby každé možné prejdenie funkciou bolo ukončené príkazom return.

Dva spôsoby, ako napísať funkciu min, ktorá vráti menšie z dvoch zadaných čísel a a b:

int min(int a, int b) {
    int minval;
    if (a < b) {
        minval = a;
    } else {
        minval = b;
    }
    return minval;
}

int min(int a, int b) {
    if (a < b) {
        return a;
    } else {
        return b;
    }
}

Vo funkciách, ktoré vracajú void, môže ale nemusí byť return. To znamená, že oba nasledovné programy sú v poriadku.

void printmessage ()
{
  cout << "I'm a function!";
}

void printmessage ()
{
  cout << "I'm a function!";
  return;
}

Cvičenie: čo vráti nasledujúca funkcia pre n=6? Čo vráti pre n=7? Viete stručne popísať, čo robí pre všeobecné n?

int zahada(int n) {
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) { return i; }
    }
    return n;
}

Lokálne a globálne premenné

Globálne premenné sú definované mimo akejkoľvek funkcie
- môžu ich používať všetky funkcie definované pod nimi
Lokálne premenné sú definované vo vnútri funkcie
- môže ich používať iba táto funkcia

Príklad: program s globálnou premennou x a dvomi lokálnymi premennými v rôznych funkciách

#include <iostream>
using namespace std;

int x = 0;  // globálna premenná

void vypis() {
    int y = 1;  // lokálna premenná vo funkcii vypis
    cout << x << " " << y << endl;    
}

int main(void) {
    int z = 2;  // lokálna premenná vo funkcii main
    cout << x << " " << z << endl;
    vypis();
}

Viaceré funkcie môžu mať lokálne premenné s tým istým menom, každá používa tú svoju
Ak má lokálna a globálna premenná to isté meno, lokálna premenná prekryje globálnu, funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát)

Príklad:

void Fnc () {
//  i=13; – nemôžeme používať premennú i – žiadna premenná i nie je viditeľná
}

int i;

void Fnc2 () {
  i=50; // priradí sa do globálne premennej i!
  Fnc ();
}

void Fnc1 () {
  int i;
  i=2; // priradí sa do lokálnej premennej i, ktorá vznikla v tejto funkcii
    // uvedomte si, že v tomto okamihu existujú 3 premenné s menom i :
    //   i – globálna premenná,
    //   lokálna premenná i, ktorá vznikla vo funkcii main,
    //   a lokálna premenná i, ktorá vznikla v tejto funkcii.
}

void main () {
int i;
  i=1;
    // priraďuje sa do lokálnej premennej i a nie do globálnej premennej i,
    // globálna premenná i je prekrytá – identifikátor i označuje lokálnu premennú i.
  Fnc1 ();
    // lokálna premenná i má stále hodnotu 1
  Fnc2 ();
    // lokálna premenná i má stále hodnotu 1, globálna premenná i má hodnotu 50,
}

Parametre funkcií

Odovzdávanie parametrov hodnotou

Funkcie majú často parametre.

Tieto parametre sa správajú ako lokálne premenné danej funkcie
Pri volaní funkcie sa im priradí hodnota, ktorú zadal používateľ funkcie (tento mechanizmus voláme odovzdávanie parametrov hodnotou)
Túto hodnotu síce môžeme meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme

Príklad:

#include <iostream>
using namespace std;

void vypis(int x) {
    cout << "Predtym: " << x;   /* vypiseme povodnu hodnotu x */
    x++;                        /* zvysime hodnotu x o 1 */
    cout << ", potom: " << x << endl;  /* vypiseme nove x */
}

int main(void) {
    int x = 0;
    int y = 3;
    vypis(x);       /* vypise Predtym: 0, potom: 1 */
    vypis(x);       /* vypise Predtym: 0, potom: 1 */
    vypis(y);       /* vypise Predtym: 3, potom: 4 */
    vypis(y);       /* vypise Predtym: 3, potom: 4 */
    vypis(y + 7);   /* vypise Predtym: 10, potom: 11 */
}

Odovzdávanie parametrov referenciou

Ak pred meno parametra v hlavičke funkcie dáme &, parameter sa bude odovzdávať referenciou
Pri použití takejto funkcie môžeme ako parameter zadať iba premennú, nie iný výraz
Namiesto samotnej hodnoty sa funkcii pošle adresa premennej v pamäti (referencia)
Táto sa bude vo funkcii používať pod novým menom, prípadné zmeny sa prejavia aj na mieste, odkiaľ sme funkciu volali

#include <iostream>
using namespace std;

void vypis(int & x) {
    cout << "Predtym: " << x;   /* vypiseme povodnu hodnotu x */
    x++;                        /* zvysime hodnotu x o 1 */
    cout << ", potom: " << x << endl;  /* vypiseme nove x */
}

int main(void) {
    int x = 0;
    int y = 3;
    vypis(x);       /* vypise Predtym: 0, potom: 1 */
    vypis(x);       /* vypise Predtym: 1, potom: 2 */
    vypis(y);       /* vypise Predtym: 3, potom: 4 */
    vypis(y);       /* vypise Predtym: 4, potom: 5 */
    /* vypis(y + 7);   toto teraz nemozeme pouzit, y+7 nie je premenna */
}

Odovzdávanie referenciou: viac ako jedna návratová hodnota

Odovzdávanie parametra referenciou používame napríklad vtedy, ak máme vrátiť viac ako jednu hodnotu.

Funkcia stred dostane hodnotou súradnice dvoch bodov (x1,y1) a (x2,y2) a do parametrov xs, ys, ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky.

#include <iostream>
using namespace std;

void stred(double x1, double y1, double x2, double y2, double &xs, double &ys) {
    xs = (x1 + x2) / 2;
    ys = (y1 + y2) / 2;
}

int main(void) {

    double x1, y1, x2, y2;
    double x, y;

    cout << "Napiste suradnice jedneho konca usecky (oddelene medzerou): ";
    cin >> x1 >> y1;

    cout << "Napiste suradnice druheho konca usecky (oddelene medzerou): ";
    cin >> x2 >> y2;

    stred(x1, y1, x2, y2, x, y);
    cout << "Stred usecky je [" << x << "," << y << "]." << endl;
}

Odovzdávanie referenciou: Funkcia, ktorej úlohou je zmeniť svoj parameter

Ďalší dôvod pre odovzdávanie parametrov referenciou je, keď chceme vo funkcii priamo parameter meniť s trvalými následkami.

Typickým príkladom je funkcia swap, ktorá vymení hodnoty dvoch premenných, ktoré dostane ako parametre

#include <iostream>
using namespace std;

void swap(int &a, int &b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 3;
    swap(x, y);
    cout << "x=" << x << ", y=" << y << endl;
    return 0;
}

Keby sme funkcii odovzdali parameter hodnotou tj, void swap(int a, int b), vo funkcii main by sa premenné nevymenili.

Odovzdávanie indikátoru chyby

Niektoré funkcie potrebujú, aby parameter spĺňal určité podmienky. Napríklad odmocninu vieme spočítať iba z nezáporného čísla. Čo vlastne môžeme urobiť, keď dostaneme zlý parameter?

Môžeme okamžite ukončiť celý program. V knižnici cstdlib je funkcia exit, ktorá robí presne to. Má ako parameter návratovú hodnotu celého programu

double mySqrt(double x) {
    if (x < 0) { exit(1); }   // zlý vstup: ukončíme program
    else { return sqrt(x); }  // dobrý vstup: spočítame odmocninu
}

Pohodlnejší spôsob ukončenia programu pri zlom vstupe je funkcia assert z knižnice cassert, ktorá ako parameter dostane logickú hodnotu, a ak je tá hodnota nepravda, ukončí program s chybovou hláškou.
- Pri dôležitých programoch ale nechceme, aby len tak skončili pri každej chybe

double mySqrt(double x) {
    assert(x >= 0);  // tvrdime, ze x>=0, inak program skonci 
    return sqrt(x);  // teraz mozeme veselo odmocnovat 
}

Bežný spôsob, o ktorom sa budeme učiť v druhom semestri, sú takzvané výnimky (exceptions)
Môžeme vrátiť nejakú špeciálnu hodnotu, ktorá odzrkadľuje, že vstup bol zlý. Používateľ funkcie by mal túto hodnotu rozoznať od správneho výstupu funkcie. Ale dôvera v používateľa sa všeobecne v softvérovom inžinierstve neodporúča.
- Knižničná funkcia sqrt vráti pre záporné čísla špeciálnu hodnotu NaN (not a number), my vrátime napr. -1

double mySqrt(double x) {
    if (x < 0) { return -1; }  // zlý vstup: vrátime -1
    else { return sqrt(x);  }  // dobrý vstup: spočítame odmocninu
}

Môžeme ako výstup funkcie vrátiť, či sa podarilo alebo nepodarilo správne vypočítať hodnotu. Výstupom funkcie bude logická hodnota typu bool a samotnú hodnotu vrátime v parametri odovzdanom referenciou

bool mySqrt(double x, double & result) {
    if (x < 0) { return false; } // zlý vstup: vrátime false
    else {
        result = sqrt(x);    // dobrý vstup: spočítame odmocninu a vrátime true
        return true; 
    }
}

Ešte jeden príklad: Fibonacciho čísla

Fibonacciho postupnosť je postupnosť čísel, v ktorej každý ďalší člen je súčtom dvoch predchádzajúcich. Jednotlivé členy postupnosti sa nazývajú Fibonacciho čísla.

   0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393…

Na výpočet Fibonacciho čísel používame nasledovný vzťah:

F(0) = 0
F(1) = 1
F(n)=F(n-1)+F(n-2)

Napíšeme funkciu, ktorá bude počítať Fibonacciho čísla. Na otázku "Aké je ôsme Fibonacciho číslo?" teda odpovie "21".

Cvičenie: Pozor, nefunguje správne pre nulu, skúste opraviť

int fibonacci(int n) {

    int f = 1;     // Cislo F(i) 
    int oldF = 0; // Cislo F(i-1)
    
    for (int i = 2; i <= n; i++) {
        int newF = f + oldF;  // spocitaj nove F(i) pre vyssie i
        oldF = f;             // poposuvaj hodnoty
        f = newF;
    }

    return f;
}

Cvičenie: napíšte funkciu printFibonacci, ktorá vypíše prvých n Fibonacciho čísel.

Akú by mala mať hlavičku?
Skúste dva spôsoby implementácie:
- volaním funkcie fibonacci pre rôzne hodnoty n
- prepísaním tejto funkcie, aby sa hodnoty vypisovali priamo ako sa počítajú
Ktorý spôsob bude rýchlejší pre veľké n a prečo?

Ďalšie poznámky o funkciách

Kde definovať funkciu?

Funkcia musí byť definovaná pred tým, ako ju v programe použijeme, aby kompilátor vedel skontrolovať korektnosť jej použitia (počet parametrov, ich typ..).

V prípade, že to nie je možné urobiť, potrebujeme aspoň dopredu oznámiť, že takéto funkcie budú. Urobíme to pomocou prototypu funkcie type name ( argument_type1, argument_type2, ...);

#include <iostream>
using namespace std;

void odd (int a);   // prototypy
void even (int a);

int main ()
{
  int i;
  do {
    cout << "Type a number (0 to exit): ";
    cin >> i;
    odd (i);
  } while (i!=0);
  return 0;
}

void odd (int a)
{
  if ((a%2)!=0) cout << "Number is odd.\n";
  else even (a);
}

void even (int a)
{
  if ((a%2)==0) cout << "Number is even.\n";
  else odd (a);
}

Funkcia main

Má od ostatných funkcií niekoľko odlišností

Síce má návratový typ (int), ale nemusí nič vracať.
V programe sa nemôže volať - jediné jej volanie je automatické (začína sa ním beh programu)
Má predpísané argumenty, ktoré sa dajú vynechať (viac o nich neskôr)

Príklad: obmena problému z cvičení

Máme dané dva intervaly [a,b] a [c,d] a chceme buď vypísať ich prienik, alebo správu, že sú disjunktné. Podobný príklad sme riešili na cvičeniach pomocou vnorených podmienok.

Vzniká viacero možností, podľa toho, či prvý interval začína naľavo alebo napravo od druhého
Prácu si teda zjednodušíme tým, že ak je prvý interval napravo, prehodíme intervaly.
Potom máme isté, že prvý interval začína skôr ako druhý, a teda intervaly sú disjunktné práve vtedy, ak prvý aj skončí skôr ako druhý začne.
V opačnom prípade je prienik od začiatku druhého intervalu po prvý koniec, teda menšie z čísel b,d.
V programe môžeme využiť funkcie min a swap, ktoré sme videli vyššie.
- Dobre navrhnuté funkcie sa často dajú použiť vo viacerých programoch.

#include <iostream>
using namespace std;

void swap(int &x, int &y) {
    int tmp = x;
    x = y;
    y = tmp;
}

int min(int x, int y) {
    if (x < y) {
        return x;
    } else {
        return y;
    }
}

int main(void) {
    int a, b, c, d;
    cout << "Zadajte zaciatok a koniec prveho intervalu: ";
    cin >> a >> b;
    cout << "Zadajte zaciatok a koniec druheho intervalu: ";
    cin >> c >> d;

    /* Chceme, aby zaciatok prveho intervalu bol <= zaciatku druheho. */
    if (c < a) {
        swap(a, c);
        swap(b, d);
    }

    if (b < c) {
        cout << "Intervaly su disjunktne." << endl;
    } else {
        cout << "Ich prienik je interval [" << c << "," << min(b, d) << "]" << endl;
    }
}

Zhrnutie

Funkcie nám umožňujú rozbiť väčší program na menšie logické časti a tým ho sprehľadniť. Tiež nám umožňujú vyhnúť sa opakovaniu podobných kusov kódu.
Hlavička funkcie obsahuje návratový typ (môže byť void), meno funkcie, typy a mená parametrov.
V tele funkcie sú samotné príkazy. Vypočítanú hodnotu vrátime príkazom return.
Lokálne premenné sú viditeľné len vo funkcii, ktoré ich definuje, globálne vo všetkých funkciách.
Parametre odovzdávané hodnotou sú lokálne premenné inicializované určitou hodnotou, ktorú zadá užívateľ funkcie.
Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú.

Organizačné poznámky

Na stránke zverejnené zadania DÚ2, odovzdávajte do piatku
V priebehu týždňa bude zverejnená DÚ3
Pokročilá DÚ1 je zverejnená, odovzdávajte do piatku 18.10. 22:00 (ak ich chcete riešiť miesto bežných DÚ, kontaktujte vyučujúcich).
Výsledky testu pre pokročilých boli poslané emailom
Výsledky DÚ a rozcvičiek budete časom vidieť v odovzdávacom systéme.
Tento týždeň opäť prednášky, cvičenia a rozcvička (z minulotýždenných cvičení)
Nezabudnite si prípadné zmeny v zápise dať potvrdiť na študijnom (v období od 7.10. do 10.10.2013). Pred koncom tejto doby bývajú na študijnom dlhé rady, choďte čím skôr.

Prednáška 5

Štatistika z N čísel

Od užívateľa postupne načítame N čísel a chceme o nich zistiť nejaké štatistické údaje.

Predstavme si napríklad, že učiteľ zadá body, ktoré študenti dostali na písomke.

Maximum

Zrejme stačí čítať čísla postupne a pamätať si zatiaľ najväčšie číslo.

#include <iostream>
#include <cstdlib>

using namespace std;

int main(void) {
    int max, x, N;

    cout << "Zadaj pocet cisel: ";
    cin >> N;

    cout << "Zadavajte cisla: ";

    max = ?
    for (int i = 0; i < N; i++) {
        cin >> x;
        if (x > max) {
            max = x;
        }
    }

    cout << endl << "Maximum je " << max << endl;
}

Ako ale začať? Ako nastaviť maximum na začiatok?

Jedna možnosť je nastaviť ho na nejakú veľmi malú hodnotu, aby sa iste neskôr zmenila. Kto nám ale zaručí, že používateľ nedá všetky čísla ešte menšie?
Riešením je použiť najmenšie možné číslo - ale je príliš viazané na konkrétny rozsah, nebude fungovať po zmene typu premenných.
Ďalšia možnosť je si pamätať, že ešte nemáme správne nastavené maximum a po načítaní prvého čísla ho nastaviť.

#include <iostream>
#include <cstdlib>

using namespace std;

int main(void) {
    int max, x, N;

    cout << "Zadaj pocet cisel: ";
    cin >> N;

    cout << "Zadavajte cisla: ";
    cin >> x;

    max = x;
    for (int i = 1; i < N; i++) {
        cin >> x;
        if (x > max) {
            max = x;
        }
    }

    cout << endl << "Maximum je " << max << endl;
}

Cvičenie:

Čo treba v programe zmeniť, ak chceme hľadať minimum namiesto maxima?
Ako by sme spočítali priemer čísel?

Výskyty čísel 0..9

Na vstupe sú iba čísla od 0 do 9 a chceme vedieť, koľko jednotlivých čísel je. Mohli by sme to riešiť takto:

Pre každú možnú hodnotu si vytvoríme jednu premennú (dokopy ich bude teda 10 - napríklad p0, p1 .. p9) na začiatku nastavenú na 0.
V prípade, že prečítané číslo bolo 0 zväčšíme hodnotu p0, ak bolo 1 zväčšíme p1 ...

Bol by to dlhý a komplikovaný program, v ktorom sa ľahko spraví chyba. Už vôbec by nebolo praktické to robiť takto ak by hodnoty boli od 0 po milión...

To, že štvrtá premenná je p4, vieme iba my ako programátori a počítač o tom nevie - nemá žiaden súvis medzi jednotlivými premennými.

Teraz ukážeme riešenie tohto príkladu pomocou poľa.

int p[10] vytvorí pole dĺžky 10, t.j. tabuľku s prvkami p[0], p[1],..., p[9]
s každým p[i] môžeme pracovať ako s premennou typu int

#include <iostream>
using namespace std;

int main(void) {
    int p[10];  // pole dlzky 10
    int N;
    cout << "Zadajte pocet cisel: ";
    cin >> N;

    for (int i = 0; i < 10; i++) p[i] = 0; // inicializácia pola p[0]=0; p[1]=0; ... p[9]=0;

    cout << "Zadavajte " << N << "cisel z intervalu 0-9: ";
    for (int i = 0; i < N; i++) {
        int x;
        cin >> x;
        if (x >= 0 && x < 10) p[x]++; // test, či je číslo z požadovaného rozsahu
    }

    cout << endl;
    for (int i = 0; i < 10; i++) {
        cout << "Pocet vyskytov " << i << " je " << p[i] << endl; // výpis
    }
}

Podpriemer / nadpriemer

Chceme spočítať priemer a o každom vstupnom čísle vypísať, či je nadpriemerné alebo podpriemerné.

Priemer vieme až keď načítame všetky čísla, musíme si ich teda zapamätať
Keby sme vedeli dopredu, koľko ich bude vedeli by sme to urobiť podobne ako v predchádzajúcom príklade.

#include <iostream>
using namespace std;

int main(void) {
    const int N = 20; // premennu N uz nebude mozne menit, ma konstantnu hodnotu 20
    int p[N];
    double sucet = 0;

    cout << "Zadavajte " << N << " cisel: ";
    for (int i = 0; i < N; i++) {
        cin >> p[i];
        sucet += p[i];
    }

    double priemer = sucet / N;
    cout << "Priemer je " << priemer << "." << endl;
    for (int i = 0; i < N; i++) {
        if (p[i] > priemer) cout << p[i] << ": vacsie ako priemer." << endl;
        else if (p[i] < priemer) cout << p[i] << ": mensie ako priemer." << endl;
        else cout << p[i] << ": priemer." << endl;
    }
}

Pozor, chyby pri zaokrúhľovaní môžu spôsobiť, že niekedy priemerné číslo bude považované za nad/podpriemerné
- Vedeli by ste program prerobiť tak, aby používal iba premenné typu int a nerobil žiadnu chybu v zaokrúhľovaní?
- Môže aj po takejto zmene niekedy dať zlú odpoveď?

Polia

Rozsah poľa je konštantný výraz väčší ako 0. Prvky sa indexujú od 0 po počet - 1

int a[10];
const int N=20;
double b[N];

Ak nepoznáme vopred počet prvkov, ktoré chceme dať do poľa, môžeme odhadnúť, že ich nebude viac ako NMax, ktoré definujeme ako konštantu v programe.

Vytvoríme pole veľkosti NMax, použijeme z neho len prých N hodnôt

    const int NMax = 1000;
    int p[NMax];
    int N;
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    if (N > NMax) {
        cout << "Prilis velke N" << endl;
        return 1;
    }
   cout << "Zadavajte " << N << " cisel: ";
   ...

Nie je možné priamo zadefinovať ako veľkosť poľa premennú N, ktorú si prečítame od používateľa alebo inak spočítame za behu

    int N;
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    int p[N];

V niektorých verziách C resp. C++ to funguje
Pole veľkosti N, ktorá nie je konštanta, sa naučíme vytvárať trochu inak v druhej polovici semestra

Vytvorenie a inicializácia poľa

V definícii môžeme pole inicializovať zoznamom prvkov.

int A[4]={3, 6, 8, 10}; //spravne
int B[4]; //spravne
B[4]={3, 6, 8, 10};  //nespravne, pole to nedefinujeme
B[0]=3; B[1]=6; B[2]=8; B[3]=10;  // spravne - menime prvky existujuceho pola

Pri inicializácii sa dá dodať aj menej hodnôt ako má pole. Pri čiastočnej inicializácii nastaví prekladač ostatné prvky na nulu.

double C[5]={5.0, 13.9}; // inicializuje C[0]=5.0, C[1]=13.9 a C[2]..C[4]=0
double C[5]={0}; // jednoduchá inicializácia všetkých prvkov na 0

Ak pri inicializácii poľa necháme hranaté zátvorky prázdne, prekladač si sám spočíta prvky poľa. Nie je to však odporúčaný postup.

int A[]={1, 5, 3, 8}; // zistí rozsah poľa 0..3

Indexovanie hodnotou mimo intervalu

Pozor, kompilátor nekontroluje indexy prvkov

  int a[10];
  a[10] = 1234;

Skompilujete, ale hodnota 1234 sa zapíše do pamäte na zlé miesto,
Môže to mať nepredvídateľné následky: prepísanie obsahu iných premenných (chybný výpočet alebo „nevysvetliteľné“ správanie sa programu) alebo dokonca prepísanie časti kódu vášho programu

Kopírovanie a testovanie rovnosti

V prípade, že chceme vytvoriť pole, ktoré je kópiou už existujúceho poľa, ponúka sa možnosť príkazu priradenia b=a;. Takýto príkaz však neskompilujete – nedá sa takto priraďovať, treba kopírovať prvok po prvku.

  for (i=0; i<10; i++) b[i]=a[i];

Podobne sa nedá porovnávať polia pomocou podmienky if (a==b) cout << "Ok";. Takúto podmienku síce skompilujete, ale nikdy to nebude pravda – neporovná sa obsah poľa, ale niečo úplne iné (adresy polí v pamäti). Treba to riešiť opäť prvok po prvku.

  bool rovne = true;
  for (i = 0; i < 10; i++) { rovne = rovne && a[i] == b[i]; }
  if (rovne) cout << "Ok\n";

Príklady na prácu s poľom

Načítajte pole čísel a vypíšte ho v opačnom poradí.
Skúste poradie povymienať priamo v poli a nie iba pri výpise.

Načítajte pole čísel a vypíšte ho v náhodnom poradí.
Ako by ste pole náhodne povymieňali priamo v pamäti?

Kreslíme padajúce kruhy

Chceme vykresliť animáciu padajúcich kruhov

Vytvoríme si polia pre x-ovú a y-ovú súradnicu kruhu.
Potrebujeme aj pole, do ktorého si budeme dávať celočíselné identifikátory nakreslených kruhov, aby sme ich neskôr mohli zmazať.

#include "../SVGdraw.h"
#include <cstdlib>
#include <ctime>

int main(void) {
    const int count = 10; /* počet kruhov */
    const int size = 300; /* veľkosť obrázku */
    const int radius = 15; /* polomer kruhu */
    const int step = 4; /* o kolko padne dolu v jednom kroku */
    const int repeat = 100; /* pocet iteracii */
    double wait = 0.2; /* cakaj po kazdej iteracii */

    /* inicializácia generátora pseudonáhodných čísel */
    srand(time(NULL));

    SVGdraw drawing(size, size, "kruhy.svg");
    drawing.setFillColor("lightblue");

    int x[count]; /* x-ova poloha kruzku */
    int y[count]; /* y-ove poloha kruzku */
    int id[count]; /* id objektu na obrazovke */

    /* kazdemu kruzku vygeneruj nahodnu polohu */
    for (int i = 0; i < count; i++) {
        x[i] = rand() % (size - 2*radius) + radius;
        y[i] = rand() % (size - 2*radius) + radius;
    }

    /* opakuj repeat iteracii */
    for (int r = 0; r < repeat; r++) {
        /* chod cez vsetky kruhy */
        for (int i = 0; i < count; i++) {
            /* ak nie sme v prvej iteracii, treba zmazat kruh */
            if (r > 0) {
                drawing.hideItem(id[i]);
            }
            /* zvys y-ovu suradnicu o step */
            y[i] += step;
            /* ak sme prilis nizko, zacni na vrchu na nahodnom x */
            if (y[i] >= size - radius) {
                y[i] = radius;
                x[i] = rand() % (size - 2*radius) + radius;
            }
            /* vykresli kruzok na novom mieste */
            id[i] = drawing.drawEllipse(x[i], y[i], radius, radius);
        }
        /* na konci iteracie chvilu pockaj */
        drawing.wait(wait);
    }
}

Takéto polia nie sú ideálne, lebo údaje o jednom kruhu sú v troch rôznych poliach a bolo by logickejšie ich mať pokope.
Situácia by bola ešte horšia, ak by každý kruh mal napr. aj náhodnú farbu s troma zložkami R,G,B. To by sme potrebovali šesť polí.
Na spojenie údajov k jednému kruhu použijeme dátovú štruktúru struct

Padajúce kruhy so struct

Výsledok

#include "../SVGdraw.h"
#include <cstdlib>
#include <ctime>

struct kruh {
    int x, y; /* suradnice */
    int id;   /* id na mazanie */
    int r, g, b; /* zlozky farby: red, green, blue */
};

void generujKruh(kruh &k, int size, int radius) {
    k.x = rand() % (size-2*radius) + radius;
    k.y = rand() % (size-2*radius) + radius;
    k.r = rand() % 256;
    k.g = rand() % 256;
    k.b = rand() % 256;
    k.id = -1;
}

int main(void) {
    const int count = 10; /* počet kruhov */
    const int size = 300; /* veľkosť obrázku */
    const int radius = 15; /* polomer kruhu */
    const int step = 4; /* o kolko padne dolu v jednom kroku */
    const int repeat = 100; /* pocet iteracii */
    const double wait = 0.2; /* cakaj po kazdej iteracii */

    /* inicializácia generátora pseudonáhodných čísel */
    srand(time(NULL));

    SVGdraw drawing(size, size, "kruhy2.svg");

    /* pole kruhov */
    kruh kruhy[count];

    /* kazdemu kruzku vygeneruj nahodnu polohu */
    for (int i = 0; i < count; i++) {
        generujKruh(kruhy[i], size, radius);
    }

    /* opakuj repeat iteracii */
    for (int r = 0; r < repeat; r++) {
        /* chod cez vsetky kruhy */
        for (int i = 0; i < count; i++) {
            /* ak nie sme v prvej iteracii, treba zmazat kruh */
            if (r > 0) {
                drawing.hideItem(kruhy[i].id);
            }
            /* zvys y-ovu suradnicu o step */
            kruhy[i].y += step;
            /* ak sme prilis nizko, zacni na vrchu na nahodnom x */
            if (kruhy[i].y >= size - radius) {
                generujKruh(kruhy[i], size, radius);
                kruhy[i].y = radius;
            }
            /* vykresli kruzok na novom mieste */
            drawing.setFillColor(kruhy[i].r, kruhy[i].g, kruhy[i].b);
            kruhy[i].id = drawing.drawEllipse(kruhy[i].x, kruhy[i].y,
                    radius, radius);
        }
        /* na konci iteracie chvilu pockaj */
        drawing.wait(wait);
    }
}

Eratostenovo sito

Chceme vypísať všetky prvočísla medzi 2 a N. Mohli by sme ísť cez všetky čísla a pre každé testovať, koľko má deliteľov (deliteľov sme už hľadali predtým), ale vieme to spraviť aj rýchlejšie. Použijeme algoritmus zvaný Eratostenovo sito.

Vytvoríme pole A pravdivostných hodnôt, kde A[i] nám hovorí, či je i ešte potenciálne prvočíslo.
Na začiatku budú všetky hodnoty true, lebo sme ešte žiadne číslo nevylúčili.
Začneme číslom 2 - toto je iste prvočíslo (tak ho vypíšeme). O jeho násobkoch však vieme, že iste nemôžu byť prvočísla - nastavíme preto pre každý násobok j=2*k pravdivostnú hodnotu A[j] na false.
Potom prechádzame v poli, kým nenájdeme najbližšiu ďalšiu hodnotu true. Toto číslo je prvočíslo (vypíšeme ho) a vyškrtáme jeho násobky.

#include <iostream>
using namespace std;

int main(void) {
    const int N = 25;
    bool A[N + 1];

    for (int i = 2; i <= N; i++) {
        A[i] = true;
    }
    for (int i = 2; i <= N; i++) {
        if (A[i]) {
            cout << i << " ";
            for (int j = 2 * i; j <= N; j = j + i) {
                A[j] = false;
            }
        }
    }
    cout << endl;
}

Výstup programu

2 3 5 7 11 13 17 19 23

Priebeh programu:

0  1  2  3  4  5  6  7  8  9 10 11 12 ...
?  ?  T  T  T  T  T  T  T  T  T  T  T ... na zaciatku
?  ?  T  T  F  T  F  T  F  T  F  T  F ... po vyskrtani i=2
?  ?  T  T  F  T  F  T  F  F  F  T  F ... po vyskrtani i=3
?  ?  T  T  F  T  F  T  F  F  F  T  F ... dalej sa uz skrtaju len vacsie cisla

Cvičenie: Napíšte funkciu, ktorá uloží prvočísla medzi 2 a N do poľa (ak by sme ich chceli použiť na ďalšie výpočty).

Zhrnutie

V prípade využívania viacerých premenných, ktoré sú vlastne jednotlivé prvky nejakej postupnosti (načítavané čísla, ..) môžeme využívať polia
Jednotlivé spolu súvisiace informácie (vlastnosti) o nejakom prvku spojíme do štruktúry pomocou struct

Reklama

V piatok od 13:10 v H6 školské kolo programátorskej súťaže ACM

Cvičenia 3

Vypisovanie čísel

Napíšte program, ktorý vypíše štvorec veľkosti NxN obsahujúci čísla nasledovne (vyskúšajte všetky tri spôsoby):

V prvom riadku budú samé 1, v druhom samé 2, .. v poslednom samé N
V každom riadku budú čísla od 1 po N
Rovnaké čísla budú uhlopriečne

1 1 1 1    1 2 3 4    1 2 3 4
2 2 2 2    1 2 3 4    2 3 4 5
3 3 3 3    1 2 3 4    3 4 5 6
4 4 4 4    1 2 3 4    4 5 6 7

Hodnotu N si na začiatku programu uložte do premennej.

Číselné sústavy

Napíšte funkciu cifernySucet, ktorá dostane ako parameter číslo N a vráti jeho ciferný súčet (napr. pre N=124 vráti 7). Funkcia main načíta číslo od užívateľa, zavolá túto funkciu a vypíše výsledok.

Napíšte funkciu pocetCifier, ktorá dostane ako parameter číslo N a vráti počet cifier, ktoré má (napr. pre N=124 vráti 3). Funkcia main načíta dve čísla a a b a vypíše ich pod seba zarovnané doprava (zistí pre obe počet cifier a pred kratšie vypíše potrebný počet medzier. Napríklad pre a=3 a b=100 vypíše:

  3
100

Hádaj číslo

Na prednáške bola naprogramovaná hra Hádaj číslo, kde si počítač "myslí číslo" od 1 do 100 a používateľ háda, o ktoré číslo ide. Upravte program nasledovne:

Program umožní používateľovi sa vzdať, napríklad keď používateľ zadá 0. V tom prípade program vypíše hľadané číslo a skončí.
Program bude počítať počet kôl, ktoré používateľ potreboval k uhádnutiu čísla a na konci ho vypíše.

Kombinačné čísla

Iste poznáte kombinačné číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k}=\frac{n!}{k!(n-k)!}} , ktoré vyjadruje, koľkými možnosťami je možné vybrať k prvkov z n-prvkovej množiny.

Vypočítajte kombinačné číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose k}} priamo z definície, t.j. pomocou funkcie, ktorá počíta faktoriál čísla.
Kombinačné čísla sa dajú počítať aj efektívnejšie. Napríklad Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {5 \choose 2} = \frac{5!}{2!3!} = \frac{5\cdot4\cdot 3\cdot 2\cdot 1}{2\cdot 1\cdot3\cdot2\cdot1}} sa zjavne dá zjednodušiť na Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {5 \choose 2} = \frac{5\cdot4}{2\cdot 1}} . Vytvorte funkciu, ktorá počíta kombinačné číslo týmto spôsobom. Vieme túto funkciu upraviť tak, aby nepočítala najskôr čitateľa a potom menovateľa a pritom ostal jej výsledok stále typu int?
Pomocou predchádzajúcej funkcie vypíšte do jedného riadku hodnoty Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i}} pre používateľom zadané n a všetky i od 0 po n.
Funkciu pre vypísanie celého riadku vieme optimalizovať nasledovne: Na základe čísla Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i}} budeme počítať Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n\choose i+1}} . Vypíšte riadok Pascalovho trojuholníka takýmto spôsobom.

Grafická funkcia

Napíšte funkciu, ktorá do grafického okna vykreslí domček z prvej resp. druhej prednášky. Ako parameter dostane súradnice ľavého dolného rohu domčeka, jeho výšku, šírku a výšku strechy, ale aj obrázok, do ktorého vykresľujeme (prenesieme ho ako referenciu - pomocou SVGdraw & drawing).
- V hlavnom okne použite túto funkciu na vykreslenie domčekov rôznej farby na nieľkokých miestach na obrázku.

Prednáška 6

Organizačné poznámky

DÚ3 a PDÚ1 do piatka. DÚ4 zverejnená v priebehu týždňa, PDÚ2 začiatkom budúceho týždňa.
Spýtajte sa, ak niečo nie je jasné, alebo ak máte problémy úlohu riešiť.

Prebrali sme premenné, polia, podmienky, cykly a funkcie.
- Z týchto stavebných prvkov sa dajú vystavať pomerne komplikované programy. Menej skúsení programátori si potrebujú prácu s týmito pojmami čo najviac precvičiť. Skúste si vyriešiť všetky príklady z cvičení. Kontaktujte nás, ak Vám niečo nie je jasné.
- Predbežný plán: tento a budúci týždeň algoritmy s poliami, znaky a reťazce. Utorok budúci týždeň začneme rekurziu (veľa študentom robila problém na skúške).

Parametre funkcií - prehľad, opakovanie

Jednoduché typy, napr. int, double, bool
- Bez & sa skopíruje hodnota
- S & premenná dostane vo funkcii nové meno

void f1(int x) {
    x++; // zmena x sa nepresenie do main (y zostane rovnaká)
    cout << x << endl;
}

void f2(int &x) {
    x++; // zmena x sa prenesie ako zmena y v main
    cout << x << endl;
}

int main(void) {
    int y = 0;
    f1(y);
    f2(y);
    f1(y + 1);
    //zle: f2(y+1);
}

Polia odovzdávame bez &
- väčšinou potrebujeme poslať aj veľkosť poľa, ak nie je globálne známa
- zmeny v poli zostanú aj po skončení funkcie

void f(int a[], int n) {
    for (int i = 0; i < n; i++) {
        cout << a[i] << endl;
    }
}

int main(void) {
    int b[3] = {1, 2, 3};
    f(b, 3);
}

Turtle a SVGdraw obrázok sú v skutočnosti objekty, väčšinou ich chcete posielať s &
- všetky zmeny na nich spravené pretrvávajú aj po skončení funkcie

void kresli(Turtle &t, int n) {
  for(int i=0; i<n; i++) {
     t.turnLeft(rand() % 360);
     t.forward(10);
  }
}
int main(void) {
    int n=10;    
    Turtle turtle(500, 500, "chod.svg", window, 250, 450, 0);
    kresli(turtle, n);
    turtle.finish();
}

Štruktúry (struct) väčšinou tiež posielame pomocou &
Návratové hodnoty:
- ak je výsledkom funkcie jedno číslo alebo pravdivostná hodnota, vrátime ju príkazom return
- ak je výsledkom viac hodnôt, alebo niečo zložitejšie (pole, struct,...), odovzdáme ho ako parameter pomocou &, návratová hodnota môže zostať void
Tieto pravidlá súvisia so smerníkmi a správou pamäti, povieme si viac o pár týždňov

Polynómy

Príklad polynómu: Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 3x -1} .
Polynóm si môžeme uložiť do poľa, pričom koeficient pri Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^i} dáme do a[i]
Pre náš príklad vytvoríme pole napríklad príkazom double a[4] = {-1, 3, 0, 2};
Teraz si ukážeme niekoľko funkcií, ktoré s polynómami pracujú.

Vyhodnocovanie polynómu

Chceme spočítať hodnotu polynómu pre nejaké konkrétne x
Príklad: pre Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 3x -1} a pre x=2 dostaneme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 21 = (2\cdot 2^3 + 3\cdot 2 -1)}

Pokus 1:

double evaluatePolynomial(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia na výpočet x na i používa funkciu
     * pow, čo ale pomalé a potenciálne nie úplne presné.
     */
    double value = 0;
    for (int i = 0; i < n; i++) {
        value += a[i] * pow(x, i);
    }
    return value;
}

Pripomíname: value += x je to isté ako value = value + x
Všimnite si, že v komentári na začiatku funkcie popisujeme, čo tá funkcia robí, to je väčšinou dobrý nápad spraviť.
Aký najvyšší stupeň môže mať polynóm a (ako funkcia n)?

Pokus 2:

Vyhneme sa volaniu pow tým, že budeme nejakú premennú opakovanie násobiť hodnotou x
V cykle uvádzame ako komentár invariant, podmienku, ktorá na tom mieste vždy platí. Takýto invariant nám pomôže si uvedomiť, že je náš program správny.
Čo by sa stalo, ak by sme prehodili dva príkazy vo vnútri cyklu?

double evaluatePolynomial(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia počíta x na i v cykle spolu
     * s vyhodnocovaním polynómu.
     */
    double value = 0;
    double xpow = 1;
    for (int i = 0; i < n; i++) {
        /* Invariant: xpow sa rovna x na i */
        value += a[i] * xpow;
        xpow *= x;
    }
    return value;
}

Pokus 3: Hornerova schéma

O kúsoček lepšia ako pokus 2 - nepotrebuje pomocnú premennú a v každej iterácii cyklu robí iba jedno násobenie, nie dve
Idea je začať od najvyšších mocnín x:
- Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2x^3 + 0x^2 + 3x -1 = ((2\cdot x+0)x+3)x-1}

double evaluatePolynomial(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia používa tzv. Hornerovu schému,
     * ktorá začína od najvyšších koeficentov a
     * a pre každé i robí iba jedno sčítanie a jedno násobenie.
     */
    double value = 0;
    for (int i = n - 1; i >= 0; i--) {
        value = value * x + a[i];
    }
    return value;
}

Cvičenie: aký je invariant po vykonaní príkazu v cykle?

Hlavný program:

#include <cstdlib>
#include <cmath>
#include <iostream>
using namespace std;

double evaluatePolynomial(double a[], int n, double x) {
  // jedna z funkcií vyššie
}

void enterPolynomial(double a[], int &n, int maxN) {
    /* Od užívateľa načíta koeficienty polynómu do a,
     * ich počet uloží do n, maxN je veľkosť poľa,
     * ktorú nemožno prekročiť. */
    cout << "Zadaj pocet koeficientov n: ";
    cin >> n;
    if (n > maxN) {
        cout << "Prilis velke n!" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++) {
        cout << "Zadaj koeficient pri x na " << i << ": ";
        cin >> a[i];
    }
}

int main(void) {
    const int maxN = 100;
    int n;
    double a[maxN];

    enterPolynomial(a, n, maxN);
    double x;
    cout << "Zadaj x: ";
    cin >> x;
    cout << "Hodnota pre x=" << x << " je " << evaluatePolynomial(a, n, x) << endl;
}

Zadaj pocet koeficientov n: 4
Zadaj koeficient pri x na 0: -1
Zadaj koeficient pri x na 1: 3
Zadaj koeficient pri x na 2: 0
Zadaj koeficient pri x na 3: 2
Zadaj x: 2
Hodnota pre x=2 je 21

Sčítanie polynómov

Pri sčítaní polynómov len sčítame koeficienty pri zodpovedajúcich mocninách x
Napr. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle (2x^3 + 3x -1) + (-4x^2+2x+7) = (2+0)x^3 + (0-4)x^2 +(3+2)x^1 + (-1+7)x^0 = 2x^3-4x^2+5x+6}
Musíme dávať pozor na to, že dĺžky polynómov môžu byť rôzne a hodnoty v poli za n ďalej sú nedefinované.

void addPolynomials(double a[], int na, double b[], int nb, double c[], int &nc) {
    /* a je pole koeficientov polynomu s na hodnotami,
     * b je pole koeficientov s nb hodnotami
     * do c zratame ich sucet, do nc pocet hodnot, ktory bude vacsie z
     * na, nb. Predpokladame, ze c je dost velke, aby sa do neho nc
     * prvkov zmestilo. */
    if (na > nb) {
        nc = na;
    } else {
        nc = nb;
    }

    for (int i = 0; i < nc; i++) {
        c[i] = 0;
        if (i < na) {
            c[i] += a[i];
        }
        if (i < nb) {
            c[i] += b[i];
        }
    }
}

Hlavný program: (teraz vidíme, načo nám je funkcia enterPolynomial, bez nej by sme cyklus na načítavanie museli písať dvakrát)

#include <cstdlib>
#include <iostream>
using namespace std;

void enterPolynomial(double a[], int &n, int maxN) {
  // pozri vyššie
}

void writePolynomial(double a[], int n) {
    /* a je pole koeficientov polynómu s n hodnotami */
    for (int i = 0; i < n; i++) {
        cout << "Koeficient polynomu pri x na " << i << " je " << a[i] << endl;
    }
}

int main(void) {
    const int maxN = 100;
    int na, nb;
    double a[maxN], b[maxN];
 
    cout << "Prvy polynom:" << endl;
    enterPolynomial(a, na, maxN);
    cout << endl << "Druhy polynom:" << endl;
    enterPolynomial(b, nb, maxN);

    double c[maxN];
    int nc;
    addPolynomials(a, na, b, nb, c, nc);
    cout << endl << "Ich sucet:" << endl;
    writePolynomial(c, nc);
}

Príklad behu:

Prvy polynom:
Zadaj pocet koeficientov n: 4
Zadaj koeficient pri x na 0: -1
Zadaj koeficient pri x na 1: 3
Zadaj koeficient pri x na 2: 0
Zadaj koeficient pri x na 3: 2

Druhy polynom:
Zadaj pocet koeficientov n: 3
Zadaj koeficient pri x na 0: 7
Zadaj koeficient pri x na 1: 2
Zadaj koeficient pri x na 2: -4

Ich sucet:
Koeficient polynomu pri x na 0 je 6
Koeficient polynomu pri x na 1 je 5
Koeficient polynomu pri x na 2 je -4
Koeficient polynomu pri x na 3 je 2

Ďalšie príklady s polynómami

Vieme napísať aj ďalšie funkcie alebo programy na prácu s polynómami:

Vykresľovanie grafu (rátame hodnotu polynómu v husto rozmiestnených bodoch)
Násobenie polynómov
Delenie so zvyškom a Euklidov algoritmus
Derivácia
A mnohé ďalšie

Načo sú v programovaní dobré funkcie

Rozbijeme veľký problém na menšie dobre definované časti (napr. načítaj polynóm, spočítaj jeho hodnotu), každou časťou sa môžeme zaoberať zvlášť. Výsledný program je ľahšie pochopiteľný, najmä ak u každej funkcie napíšeme, čo robí.
Vyhneme sa opakovaniu kusov kódu (napr. načítanie polynómu A a B). Pri kopírovaní kusov kódu ľahko narobíme chyby, a ak chceme niečo meniť, musíme meniť na veľa miestach.
Hotové funkcie môžeme použiť aj v ďalších programoch, prípadne z nich zostavovať nové knižnice, napríklad knižnicu na prácu s polynómami.

Triedenia

Máme pole čísel, chceme ich usporiadať od najmenšieho po najväčšie.

Napr. pre pole 9 3 7 4 5 2 chceme dostať 2 3 4 5 7 9
Jeden z najštudovanejších problémov v informatike.
Súčasť mnohých zložitejších algoritmov.
Veľa spôsobov, ako triediť, dnes si ukážeme zopár najjednoduchších.

Bublinkové triedenie (Bubble Sort)

Idea: Kontrolujeme všetky dvojice susedných prvkov a keď vidíme menšie číslo za väčším, vymeníme ich

       for (int i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                swap(a[i - 1], a[i]);
            }
        }

Ak sme nenašli v poli žiadnu dvojicu, ktorú treba vymeniť, skončili sme.
Inak celý proces opakujeme znova.

Celé triedenie:

void swap(int &x, int &y) {
    /* Vymeň hodnoty premenných x a y. */
    int tmp = x;
    x = y;
    y = tmp;
}

void sort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    bool hotovo = false;
    while (!hotovo) {
        bool vymenil = false;
        /* porovnávaj všetky dvojice susedov, vymeň ak menší za väčším */
        for (int i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                swap(a[i - 1], a[i]);
                vymenil = true;
            }
        }
        /* ak sme žiadnu dvojicu nevymenili, môžeme skončiť. */
        if (!vymenil) {
            hotovo = true;
        }
    }
}

Čo ak vo for cykle dám for (int i = 0; i < n; i++) {
Ako nahradím premennú hotovo príkazom break?

Príklad behu:

prvá iterácia while cyklu
 9 3 7 4 5 2
 3 9 7 4 5 2
 3 7 9 4 5 2
 3 7 4 9 5 2
 3 7 4 5 9 2
 3 7 4 5 2 9

druhá iterácia while cyklu
 3 7 4 5 2 9
 3 4 7 5 2 9
 3 4 5 7 2 9
 3 4 5 2 7 9

tretia iterácia while cyklu
 3 4 5 2 7 9
 3 4 2 5 7 9

štvrtá iterácia while cyklu
 3 4 2 5 7 9
 3 2 4 5 7 9

piata iterácia while cyklu
 3 2 4 5 7 9
 2 3 4 5 7 9

Cvičenie: Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje vonkajší while cyklus?

Utriedené pole 1,2,...,n
Pole n,1,2,...,n-1
Pole 2,3,...,n,1
Pole n,n-1,...,1

Triedenie výberom (selection sort, max sort)

Idea: nájdime najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď.

int maxIndex(int a[], int n) {
    /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */
    int index = 0;
    for(int i=1; i<n; i++) {
        if(a[i]>a[index]) {
            index = i;
        }
        /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/
    }
    return index;
}

void sort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for(int kam=n-1; kam>=1; kam--) {
        /* invariant: a[kam+1]...a[n-1] sú utriedené
         * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */
        int index = maxIndex(a, kam+1);
        swap(a[index], a[kam]);
    }
}

Príklad behu programu

Vstup           9 3 7 4 5 2 
Po výmene (9,2) 2 3 7 4 5 9
Po výmene (7,5) 2 3 5 4 7 9
Po výmene (5,4) 2 3 4 5 7 9
Po výmene (4,4) 2 3 4 5 7 9
Po výmene (3,3) 2 3 4 5 7 9

Cvičenie: Bude čas behu algoritmu výrazne odlišný pre pole utriedené správne a pole utriedené v opačnom poradí?

Triedenie vkladaním (Insertion Sort)

Idea:

v prvej časti poľa prvky v utriedenom poradí
zober prvý prvok z druhej časti a vlož ho na správne miesto v utriedenom poradí

Príklad behu algoritmu:

 9 3 7 4 5 2
 3 9 7 4 5 2
 3 7 9 4 5 2
 3 4 7 9 5 2
 3 4 5 7 9 2
 2 3 4 5 7 9

Ako spraviť vkladanie:

Vkladaný prvok si zamätáme v pomocnej premennej
Utriedené prvky posúvame o jedno doprava, kým nenájdeme správne miesto pre odložený prvok

void sort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for (int i = 1; i < n; i++) {
        int prvok = a[i];
        int kam = i;
        while (kam > 0 && a[kam - 1] > prvok) {
            a[kam] = a[kam - 1];
            kam--;
        }
        a[kam] = prvok;
    }
}

Všimnime si podmienku (kam > 0 && a[kam - 1] > prvok)
- Ak kam==0, prvá časť je false, druhá časť sa už nevyhodnocuje
- Ak by sme prehodili časti, program by mohol spadnúť (a[kam - 1] > prvok && kam > 0)

Cvičenie: Ako sa bude správať algoritmus na nasledujúcich vstupoch, koľkokrát zopakuje priradenie a[kam]=a[kam-1]?

Utriedené pole 1,2,...,n
Pole n,1,2,...,n-1
Pole 2,3,...,n,1
Pole n,n-1,...,1

Zhrnutie

Videli sme niekoľko nových algoritmov:
- Vyhodnocovanie a sčítavanie polynómov
- Tri jednoduché algoritmy na triedenie
  - Neskôr sa ešte naučíme rýchlejšie algoritmy na triedenie, ktoré používajú rekurziu

Precvičili sme si funkcie, parametre a polia
K funkciám je dobré napísať, čo robia
Do cyklov si môžeme písať invarianty
- Používajú sa pri formálnom dokazovaní správnosti
- Pomáhajú pochopeniu kódu
- Môžeme ich použiť na ručnú alebo automatickú kontrolu správnosti hodnôt premenných
- Príkaz assert v knižnici cassert kontroluje podmienku, napr. assert(i>=0 && i<n); ukončí program s chybovou hláškou ak podmienka neplatí

Zdrojový kód programu s polynómami

/* Program s polynómami z prednášky 6. 
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_6 */
#include <cstdlib>
#include <cmath>
#include <iostream>
using namespace std;

const int maxN = 100;

double evaluatePolynomialPow(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia na výpočet x na i používa funkciu
     * pow, čo ale pomalé a potenciálne nie úplne presné.
     */
    double value = 0;
    for (int i = 0; i < n; i++) {
        value += a[i] * pow(x, i);
    }
    return value;
}

double evaluatePolynomialMult(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia počíta x na i v cykle spolu
     * s vyhodnocovaním polynómu.
     */
    double value = 0;
    double xpow = 1;
    for (int i = 0; i < n; i++) {
        /* Invariant: pow sa rovna x na i */
        value += a[i] * xpow;
        xpow *= x;
    }
    return value;
}

double evaluatePolynomialHorner(double a[], int n, double x) {
    /* a je pole koeficientov s n hodnotami.
     * Funkcia vráti hodnotu tohto polynómu v bode x.
     *
     * Táto implementácia používa tzv. Hornerovu schému,
     * ktorá začína od najvyšších koeficentov a
     * a pre každé i robí iba jedno sčítanie a jedno násobenie.
     */
    double value = 0;
    for (int i = n - 1; i >= 0; i--) {
        value = value * x + a[i];
    }
    return value;
}

void addPolynomials(double a[], int na, double b[], int nb, double c[], int &nc) {
    /* a je pole koeficientov polynomu s na hodnotami,
     * b je pole koeficientov s nb hodnotami
     * do c zratame ich sucet, do nc pocet hodnot, ktory bude vacsie z
     * na, nb. Predpokladame, ze c je dost velke, aby sa do neho nc
     * prvkov zmestilo. */
    if (na > nb) {
        nc = na;
    } else {
        nc = nb;
    }

    for (int i = 0; i < nc; i++) {
        c[i] = 0;
        if (i < na) {
            c[i] += a[i];
        }
        if (i < nb) {
            c[i] += b[i];
        }
    }
}

void enterPolynomial(double a[], int &n, int maxN) {
    /* Od užívateľa načíta koeficienty polynómu do a,
     * ich počet uloží do n, maxN je veľkosť poľa,
     * ktorú nemožno prekročiť. */
    cout << "Zadaj pocet koeficientov n: ";
    cin >> n;
    if (n > maxN) {
        cout << "Prilis velke n!" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++) {
        cout << "Zadaj koeficient pri x na " << i << ": ";
        cin >> a[i];
    }
}

void writePolynomial(double a[], int n) {
    /* a je pole koeficientov polynómu s n hodnotami */
    for (int i = 0; i < n; i++) {
        cout << "Koeficient polynomu pri x na " << i << " je " << a[i] << endl;
    }
}

void testEvaluate() {
    int n;
    double a[maxN];

    enterPolynomial(a, n, maxN);
    double x;
    cout << "Zadaj x: ";
    cin >> x;
    cout << "Hodnota pre x=" << x << " je " << evaluatePolynomialPow(a, n, x) << endl;
    cout << "Hodnota pre x=" << x << " je " << evaluatePolynomialMult(a, n, x) << endl;
    cout << "Hodnota pre x=" << x << " je " << evaluatePolynomialHorner(a, n, x) << endl;
}

void testAdd() {
    int na, nb;
    double a[maxN], b[maxN];
    cout << "Prvy polynom:" << endl;
    enterPolynomial(a, na, maxN);
    cout << endl << "Druhy polynom:" << endl;
    enterPolynomial(b, nb, maxN);
    double c[maxN];
    int nc;
    addPolynomials(a, na, b, nb, c, nc);
    cout << endl << "Ich sucet:" << endl;
    writePolynomial(c, nc);
}

int main(void) {

    testEvaluate();
    testAdd();

}

Zdrojový kód programu s triedeniami

/* Program s triedeniami z prednášky 6.
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_6 */
#include <iostream>
using namespace std;

void swap(int &x, int &y) {
    /* Vymeň hodnoty premenných x a y. */
    int tmp = x;
    x = y;
    y = tmp;
}

void printArray(int a[], int n) {
   for (int i = 0; i < n; i++) {
       cout << " " << a[i];
   }
   cout << endl;
}

void bubbleSort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    bool hotovo = false;
    while (!hotovo) {
        bool vymenil = false;
        /* porovnávaj všetky dvojice susedov, vymeň ak menší za väčším */
        for (int i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                swap(a[i - 1], a[i]);
                vymenil = true;
            }
        }
        /* ak sme žiadnu dvojicu nevymenili, môžeme skončiť. */
        if (!vymenil) {
            hotovo = true;
        }
    }
}
int maxIndex(int a[], int n) {
    /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */
    int index = 0;
    for(int i=1; i<n; i++) {
        if(a[i]>a[index]) {
            index = i;
        }
        /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/
    }
    return index;
}

void selectionSort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for(int kam=n-1; kam>=1; kam--) {
        /* invariant: a[kam+1]...a[n-1] sú utriedené
         * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */
        int index = maxIndex(a, kam+1);
        swap(a[index], a[kam]);
    }
}

void insertionSort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for (int i = 1; i < n; i++) {
        // inv1
        int prvok = a[i];
        int kam = i;
        while (kam > 0 && a[kam - 1] > prvok) {
            // inv2
            a[kam] = a[kam - 1];
            kam--;
        }
        a[kam] = prvok;
    }
}

int main(void) {
    int n = 6;
    int a[6] = {9, 3, 7, 4, 5, 2};

    printArray(a, n);
    insertionSort(a, n);
    printArray(a,n);
}

Prednáška 7

Organizačné poznámky

DÚ3 a Pokročilú DÚ1 odovzdávajte do piatku 18.10. 22:00.
DÚ4 bude zverejnená v priebehu týždňa, PDÚ2 začiatkom budúceho týždňa.

Na cvičeniach si vyskúšajte najmä debugovanie, ak Vám to nejde alebo s tým máte problém pýtajte sa alebo dojdite na nepovinné cviko a pýtajte sa tam.

Vyhľadávanie prvkov poľa

Úlohou je zistiť, či pole obsahuje prvok zadanej hodnoty.

Zrejme budeme musieť prejsť celé pole, lebo nevieme, kde sa prvok môže nachádzať.

int Member(int A[], int N, int x){
 for (int i=0; i<N; i++){
   if (A[i]==x) return i;
 }  
 return -1;
}

Toto môžeme urobiť aj v prípade, že máme pole usporiadané. Prejdením celého poľa prvok iste nájdeme alebo zistíme, že sa tam taký prvok nenachádza.
Ale neexistuje lepšie riešenie?

Binárne vyhľadávanie

Lepšie riešenie samozrejme existuje a je založené na nasledovnej myšlienke:

Ak pozriem v utriedenom poli na nejaký prvok A[i], tak v intervale 0..(i-1) sú čísla veľkosti nanajvýš A[i] a v intervale (i+1)..(N-1) sú čísla veľkosti aspoň A[i].
Keď teda hľadám nejaký prvok x, tak po jednom nahliadnutí do poľa viem
- buď priamo povedať, že ten prvok sa tam nachádza - ak som trafila priamo pozíciu i taku, že x=A[i]
- vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale (i+1)..(N-1) - ak som trafila pozíciu i taku, že x<A[i]
- vyhodiť (t.j. ďalej nepoužívať) časť poľa v intervale 0..(i-1) - ak som trafila pozíciu i taku, že x>A[i]
V utriedenom poli teda môžeme vyhľadávať nasledovne:
- budem si pamätať ľavý a pravý kraj, kde ešte môže byť hľadaný prvok
- vyberiem nejaký prvok z tohoto intervalu a patrične interval skrátim
- ak už je interval zlý (t.j. pravý a ľavý kraj sú naopak) tak skončí
Jediná nezodpovedaná otázka je, ako vyberám prvok, na ktorý sa pýtam

int Member(int A[], int N, int x){
 int left=0, right=N-1, index;
 while (left<=right){
   index=??;
   if (A[index]==x) {return index;}
   else if (A[index]<x) {left=index+1;}
        else {right=index-1;}
 }
 return =-1;
}

Pozrime sa na jednotlivé možnosti ako prvok vyberať (aj keď vám je už asi jasné, aký bude výsledok):

Budeme vyberať vždy prvý prvok - tým vlastne máme skoro pôvodné hľadanie. Jediný rozdiel je, že v prípade, že už dojdeme na prvok poľa, ktorý je väčší ako hľadané x, tak zastavíme a odpovieme, že prvok tam nie je.
- Beh programu si ukážeme na príklade

A[7]={2,5,41,68,72,100,156}
N=7 x=41
   left=0 right=6: index=0; A[index]<x
   left=1 right=6; index=1; A[index]<x
   left=2 right=6; index=2; A[index]=x  -> return 2
N=7 x=31
   left=0 right=6: index=0; A[index]<x
   left=1 right=6; index=1; A[index]<x 
   left=2 right=6; index=2; A[index]>x
   left=2 right=1; left>right           -> koniec while cyklu -> return -1

Budeme vyberať vždy stredný prvok teda index=(left+right)/2, čím dosiahneme, že v každom kroku zahodíme polovicu poľa.
- Beh programu si ukážeme na príklade

A[7]={2,5,41,68,72,100,156}
N=7 x=41
   left=0 right=6: index=3; A[index]>x (68>41)
   left=0 right=2; index=2; A[index]<x (5<41)
   left=2 right=2; index=1; A[index]=x -> return 2
N=7 x=31
   left=0 right=6: index=3; A[index]>x (68>31)
   left=1 right=2; index=1; A[index]<x (5<31)
   left=2 right=2; index=2; A[index]>x (41>31)
   left=2 right=1; left>right           -> koniec while cyklu -> return -1

Tak nejako prirodzene máme pocit, že to druhé riešenie je lepšie. Že by malo byť asi rýchlejšie...

Zložitosť algoritmu

Ako sme viedli už napríklad na triedení a vyhľadávaní, jednu úlohu môžeme často riešiť viacerými spôsobmi. Tak intuitívne máme o niektorých pocit, že sú lepšie ako iné. Prečo a v čom sú niektoré riešenia lepšie a ako môžeme niečo také vlastne odhadovať (ináč ako intuitívne).

Čas

Často nás zaujíma, ako rýchlo nám program bude bežať. Vo väčšine prípadov táto rýchlosť nejakým spôsobom závisí od vstupných dát. Iste bude kratšie trvať utriedenie 3 prvkového poľa ako poľa s 100000 prvkami. Časovú zložitosť teda budeme odhadovať v závislosti od veľkosti vstupu.

Pre niektoré programy sa môže čas vypočítať jednoducho ako počet operácií, ktoré program vykoná. Avšak už pri použití podmienky dojdeme k situácii, kedy začneme uvažovať, čo započítať a co nie.

int main(void){
  int x,max,N;

  cout << "Zadajte N>0: ";
  cin >> N;
  cout << "Zadavajte cisla: ";

  cin >> max;
  for (int i=1; i<N; i++){
    cin >> x;
    if (x>max) {max=x;}
  }
}

Na začiatku máme 3 príkazy (cout a cin).
Pre prvý prvok následne potrebujeme jeho načítanie (priamo do premennej max v ktorej si pamätáme aktuálne maximum).
Je jasné, že pre každý ďalší z N prvkov, potrebujeme prvok načítať a opýtať sa na podmienku.
Avšak už nie pre každý prvok musíme následne použiť priradenie (tých priradení nemusíme potrebovať žiadne ale môžeme ho potrebovať v každom z N-1 prvkov)
Celkový súčet bude teda niečo medzi 3+1+(N-1)+0 a 3+1+(N-1)+(N-1)

Vo väčších programoch však to rozmedzie nie je také jednoduché vypočítať a preto sa bavíme často o najhoršom prípade, ktorý môže nastať. Okrem toho nás nezaujímajú presné čísla ale iba akýsi odhad (približná funkcia) závislá od vstupu. Ukážeme si odhad zložitosti na niektorých príkladoch.

Už spomínané hľadanie maxima. Pre každý z N prvkov potrebujeme urobiť niekoľko (aspoň jednu ale nie viac ako konštantu) operácií. Preto zložitosť bude lineárna.
Pozrime sa, ako na tom bude binárne vyhľadávanie. Pozrieme sa na najhorší možný scénár a to, že prvok nájdeme až v poslednom kroku alebo v poli nebude vôbec, teda ho neobjavíme skôr.
- V prvom kroku máme celé pole a v ňom sa pozrieme na stredný prvok a podľa jeho hodnoty zoberieme buď ľavú alebo pravú (zhruba) polovicu poľa.
- Tým pádom v druhom kroku máme pole polovičnej veľkosti a robíme na ňom zase to isté.
- V každom kroku teda máme pole o poloicu menšie až kým nemáme pole veľkosti 1 - potom buď už prbvok nájdeme alebo v ďalšom krku povieme, že tam nie je.
- Akú zložitosť bude mať tento program? Zapíšeme si číslo N (počet prvkov) v dvojkovej sústave. Pri delení poľa na polovicu bude ďalšia veľkosť poľa vlastne toto číslo bez poslednej cifry. Počet krokov, ktoré potrebujeme je teda zhruba počet cifier takto zapísaného čísla, čo je Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle log_2 N} .
- Iba tak pre úplnosť dodávam, že log N je menej ako N, čiže binárne vyhľadávanie beží rýchlejšie ako lineárne (v najhoršom prípade).

Na minulej prednáške boli niektoré triedenia. Pozrime, akú zložitosť majú. Odhad zložitosti urobím na jednom príklade, zvyšné si môžete skúsiť doma alebo na cvičeniach.

Selection sort (max sort). Najprv pripomeniem hlavnú ideu: nájdeme najväčší prvok a uložme ho na koniec. Potom nájdime najväčší medzi zvyšnými a uložme ho na druhé miesto odzadu atď.

int maxIndex(int a[], int n) {
    /* vráť index, na ktorom je najväčší prvok z prvkov a[0]...a[n-1] */
    int index = 0;
    for(int i=1; i<n; i++) {
        if(a[i]>a[index]) {
            index = i;
        }
        /* invariant: a[j]<=a[index] pre vsetky j=0,...,i*/
    }
    return index;
}

void sort(int a[], int n) {
    /* usporiadaj prvky v poli a od najmenšieho po najväčší */

    for(int kam=n-1; kam>=1; kam--) {
        /* invariant: a[kam+1]...a[n-1] sú utriedené
         * a pre každé i,j také že 0<=i<=kam, kam<j<n platí a[i]<=a[j] */
        int index = maxIndex(a, kam+1);
        swap(a[index], a[kam]);
    }
}

Opäť máme program, v ktorom postupujeme v nejakých krokoch - v tomto prípade máme for-cyklus. V každom kroku musíme nájsť maximum z poľa a veľkosti kam+1. Potom už iba vymeníme takto nájdené maximum a posledný provok poľa. Pričom premenná kam je riadiaca premenná for-cyklu a v každom kroku klesá.
Otázka je, aký čas potrebujeme na hľadanie maxima z x prvkov. Odpoveď je jednoduchá - prvky musíme prejsť všetky a teda zložitosť bude lineárna, t.j. x.
Teraz si už iba spočítame: V prvom kroku hľadáme maximum z n prvkov, v druhom z n-1 ...
Teda čas, ktorý na to potrebujeme je Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle n+(n-1)+...+1=\frac{n(n+1)}{2}=\frac{n^2}{2}+\frac{n}{2}} . Zložitosť tohoto triedenia bude teda kvadratická.

Bude sa však správať rovnako (kvadraticky) na všetkých vstupoch? Ak by sme ako mieru zložitosti brali výmeny prvkov, koľkokrát zopakuje priradenie a[kam]=a[kam-1]?

   Utriedené pole 1,2,...,n
   Pole n,1,2,...,n-1
   Pole 2,3,...,n,1
   Pole n,n-1,...,1

Pamäť

Ďalší bežný dôdov prečo povedať, že nejaký algoritmus je lepší ako druhý je, keď si toho musí menej pamätať. Majme napríklad klasickú úlohu - hľadanie najväčšieho prvku. To môžeme riešiť dvomi spôsobmi.

Všetky čísla si zapamätáme do poľa a následne nájdeme maximum z poľa.
Budeme zisťovať maximum priebežne a pamätať si ho v jednej premennej.

Na prvý spôsob si potrebujeme zapamätať pole čísel - teda pre N čísel potrebujeme N prvkov poľa a ešte nejaké pomocné premenné k tomu. Na rozdiel od toho, pre druhý spôsob (priebežné počítanie) si potrebujeme pamätať iba to priebežné maximum a nejakú pomocnú premennú. Zjavne teda pre nejaké väčšie N bude druhý spôsob výrazne vhodnejší.

Znaky

Znakové konštanty sa zapisujú v jednoduchých apostrofoch: 'A'. Špeciálne znaky sa dajú zapísať pomocou ich kódu v osmičkovej alebo šestnástkovej sústave: '\101' a '\x41' reprezentujú znak s kódom 65, t.j. 'A'.

Znaky majú teda svoje kódy. Najbežnejšie sa budeme stretávať s týmito:

32: medzera
27: escape
48...57: 0...9
65...90: A...Z
97...122: a...z
-1 ... -128: (aby ste si nemysleli, že kódy sú iba kladné) rôzne symboly

Znakové premenné sú typu char. Ich veľkosť je vždy 1, teda sizeof(char) == 1

Do premennej môžem priraďovať, jej obsah zapísať alebo prečítať:

  char c='A';
  char z;
  z=c;
  cout << c;
  cin >> z;  // prečíta jeden znak (pozor, preskakujú sa biele znaky)

Znaky môžem porovnávať. Na konci programu vyššie platí nasledovné:

c=='A' ... je pravda,
c=='a' ... nie je pravda – rozlišujú sa malé a veľké písmená,
c<='Z' ... je pravda – písmená sú usporiadané: A<B< ... <Z, a<b< ... <z, aj cifry sú usporiadané: 0<1< ... <9.

Ako už bolo spomínané, pri čítaní zo streamu sa preskakujú tzv. biele znaky. Toto nie je vždy žiadúce a preto môžeme streamu nastaviť modifikátor noskipws, ktorý zruší preskakovanie takýchto znakov. Do premennej teda budeme vedieť prečítať aj medzeru.

#include <iostream>
using namespace std;

int main(void) {
  char a,b,c;
 
  cin >> noskipws >> a >> b >> c;
  cout << a << b << c;
 }

Pretypovavanie

Znakové premenné, ako už bolo spomínané majú svoje kódy. Tieto kódy sú celé čísla a preto medzi znakmi a celými číslami môžeme prechádzať úplne jednoducho.

#include<iostream>

using namespace std;

int main(void){

  int N;
  char c;

  cout << "Napiste cislo: ";
  cin >> N;                     // prečíta číslo 
  c=N;                          // do znakovej premennej môžeme číslo priradiť bez problémov
  cout << c << endl;            // vieme vypísať znak
  cout << (c+1) << endl;          // ale keď už použijeme aritm. operáciu, je to ako číslo

  cout << "Napiste znak: ";     
  cin >> c;                     // prečíta znak
  N=c;                          // do celočíselnej premennej ho priamo vieme priradiť
  cout << N << endl;
}

Okrem toho však vieme urobiť aj tzv. pretypovávanie, keď chceme aby výsledok bol konkrétneho typu. Napríklad, aby nám v prvej časti vypísalo nie ďalší kód ale ďalší znak, mohli sme výsledok pretypovať.

  cout << (char)(c+1) << endl;          // vďaka pretypovaniu dostávame na výpise zase znak

Všeobecne môžeme takýmto spôsobom môžeme meniť typ - napr. výsledku nejakej operácie.

  double x=8.344;
  int N=x;
  cout << N/3 << " " << (double)(N/3) << " " << (double)N/3 << " " << x/3 << " " << (int)x/3<< endl;

Tento program vypíše nasledovný výstup:

2 2 2.66667 2.78133 2

Hádaj číslo (kým to niekoho baví)

Viacero programov čo sme tu mali sa mohlo vykonávať viac ráz. My si ukážeme, ako upraviť program "Hádaj číslo", aby po uhádnutí ponúkol možnosť hrať znovu, pokiaľ to niekoho baví.

#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;

void HadajCislo(int number) {
    /* Pamätáme si, či sme už uhádli alebo nie. */
    bool guessed = false;
    cout << "Guess a number between 1 and 10: ";
    /* Kým užívateľ neuhádne, spýtame sa ho na ďalšiu odpoveď. */
    while (!guessed) {
        int guess;
        cin >> guess;
        /* Vyhodnotíme odpoveď. */
        if (guess < number) {
            cout << "Too low, try again: ";
        } else if (guess > number) {
            cout << "Too high, try again: ";
        } else if (guess == number) {
            guessed = true;
            cout << "Correct guess" << endl;
        }
    }
}

int main(void) {
    /* vygenerujeme náhodné číslo medzi 1 a 10 */
    srand(time(NULL));
    int number;
    char c;
    bool pokracovat = true;

    while (pokracovat) {

        number = rand() % 10 + 1;
        HadajCislo(number);

        cout << "Do you want to play again? (Y/N) ";
        cin >> c;
        if (c=='Y') {
           cout << "OK. Play once more." << endl;
        }
        else if (c=='N') {
            pokracovat=false;
        }

    }
}

Switch

V prípade, že by možností bolo viac a napríklad by sme chceli ináč reagovať v prípade iných odpovedí tak sa podmienka stane príliš komplikovanou. Preto často používame príkaz na switch, ktorý podľa hodnoty výrazu pokračuje jednou vetvou.

V našom jednoduchom príklade, by mohol switch vyzerať nasledovne:

switch (c) {
  case 'Y': cout << "OK. Play once more." << endl; break;
  case 'N': pokracovat = false;
}

Vo všeobecnosti má príkaz switch viacero rôznych prípadov vyhodnotenia výrazu v podmienke.

switch (výraz)
{
case k1: príkazy1
case k2: príkazy2
default: príkazyd
}

Takýto príkaz funguje nasledovne:

Vyhodnotí výraz.
- Ak sa hodnota zhoduje s konštantným výrazom ki v niektorom case, pokračuje prvým príkazom v príkazyi
- Ak sa nezhoduje, pokračuje prvým príkazom v prikazyd, ak existuje default, alebo pokračuje za koncom switch bloku.
Narozdiel od pascalovského case vykonávanie nekončí vykonaním posledného príkazu v prikazyi, ale pokračuje ďalej, ak nie je prerušené príkazom break.

#include <iostream.h>

void main () {
  int n;
  cout << "\n" << "Zadaj n (1,2,3,4): ";
  cin >> n;
  switch (n) {
    case 1: cout << "Jeden\n";
    case 2: cout << "Dva\n";
    case 3:
    case 4: cout << "Tri alebo styri\n";
    default: cout << "Chyba!\n";
  }
  cout << "Koniec.\n";
}

Pre n=2 sa začnú vykonávať príkazy uvedené za vetvou case 2:. Vypíše sa:

    Dva
    Tri alebo styri
    Chyba!
    Koniec.

Výhodou je, že môžeme zlúčiť viacero prípadov do jednej vetvy tým, ze príkazy napíšeme až za posledný prípad (tu vidíme napr. v situácii n=3 a n=4).

Dôležité upozornenie: break switch while

Možno ste si všimli, že v príklade Hádaj číslo som použila na ukončenie cyklu premennú pokračuj. V prípade použitia podmienky if som mohla namiesto toho urobiť cyklus nekonečný a v prípade odpovede 'N' cyklus prerušiť príkazom break. Keby som podobnú vec skúsila urobiť v prípade použitia switch program by sa neskončil nikdy. Dôvod je, že príkaz break nevyskočí zo všetkých cyklov, ale iba z najvnútornejšieho - a tým je v tomto prípade switch.

Kontrola čísla

Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak.

#include <iostream>
using namespace std;

int main(void) {
    int N = 0;
    char c;

    cout << "Zadajte cele kladne cislo: ";

    cin >> noskipws >> c;
    while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra)
        /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */
        N = N * 10 + (c - '0'); // upravime cislo N
        cin >> noskipws >> c; // a nacitame dalsi znak
    }

    if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo
        cout << "Zadali ste " << N << endl;
    } else {
        cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok
    }
}

Vďaka načítaniu znakov a ich kontroly vieme zistiť, či doteraz zadané číslo alebo čokoľvek iné zodpovedá tomu, čo program očakáva.

Cvičenia 4

Manipulácia s poľom

Napíšte funkciu, ktorá dostane pole intov a a jeho veľkosť n. Funkcia v poli nájde všetky nuly a vyhodí ich, pričom po skončení je v premennej n nový počet prvkov.

Viete spraviť funkciu tak, aby poradie nenulových prvkov zostalo to isté? T.j. z poľa {1,0,4,0,0,7} dostaneme {1,4,7}

Triedenia

Bublinkové triedenie z prednášky 6 v prvej iterácii dostane najväčší prvok na svoje miesto, po druhej už sú dva najväčšie na svojom mieste atď.
- Využite tento fakt na zrýchlenie: porovnávajte dvojice len po n-k kde k je číslo aktuálnej iterácie (program s triedeniami je tu).
Bublinkové triedenie sa dá zrýchliť ešte viac v prípade, ak si budeme pamätať posledné miesto, kde sa uskutočnila výmena. Od tohoto miesta ďalej už je pole usporiadané.

Ladenie programu (debugovanie)

Šejkrové triedenie je veľmi podobné bublinkovému. Na rozdiel od neho šejkrové po prejdení poľom jedným smerom až do konca nezačína znovu od začiatku, ale pokračuje opačným smerom od konca späť. Taktiež používa zrýchlenie spomenuté v predchádzajúcej úlohe k bublinkovému triedeniu. Šejkrové triedenie teda prechádza poľom stále tam a späť, pokiaľ sa usporiadaný začiatok nespojí s usporiadným koncom.

Nájdite všetky chyby v nasledujúcom programe. Doporučujeme najprv spraviť program skompilovateľný, potom si ho pozorne prečítať a odstrániť nezmysly a zvyšné chyby odladiť pomocou krokovania programu.

#Shakersort pre cvičenia 4

Triky s otáčaním poľa

Máme dané pole intov a a počet jeho prvkov n.

Otočte poradie prvkov v úseku poľa zadanom začiatkom a koncom.
Posuňte pole cyklicky o 1 doprava, pričom posledný prvok sa dostane na prvé miesto.
Posuňte pole cyklicky o k doprava.
- Viete to spraviť tak, aby čas výpočtu nezávisel od k? Pomôcka: skúste využiť otáčanie.

Polynómy

Na prednáške 6 sme mali program, v ktorom polynóm reprezentujeme ako pole jeho koeficientov. Napíšte funkciu, ktorá vynásobí takéto polynómy.
Vykreslite graf polynómu v knižnici SVGdraw.

Eratostenovo sito

Prepíšte Eratostenovo sito z prednášky 5, tak aby ste nehľadali prvočísla, ale všetky čísla, ktoré nie sú deliteľné žiadnym štvorcom, t.j žiadnym číslom tvaru Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle k^2} pre k>1. Sú to teda čísla 1,2,3,5,6,7,10,11,13,14,15,17,...

Shakersort pre cvičenia 4

  #include <ioscream>
  #using namespace std;
  
  void swap(int x, int y) {
      /* Vymeň hodnoty premenných x a y. */
      int tmp = x;
      x = y;
      y = tmp;
  }
  
  void printArray(int a[], int n) {
      /* Vypíš celé pole. */
     for (int i = 0; i < n; i++) {
         cout << " " << a[n];
     }
     cout << endl;
  }
  
  void shakerSort(int a[], int n) {
      /* Usporiadaj prvky v poli a od najmenšieho po najväčší. */
      /* Chodíme tam a späť, pričom vždy menej,
       * lebo na koniec v každom prechode presunieme číslo,
       * ktoré tam patrí. */
  
      int begin = 0;
      int end = n;
      int i;
      while (begin<end)
      {
          /* spravíme prechod zľava doprava */
          for (i==begin; i<end; i++);
          {
              if (a[i]>=a[i+1]) swap(a[i], a[i+1]);
          }
          end--;
          /* spravíme prechod sprava doľava */
          for (i==end; i>begin; i++);
          {
              if (a[i]>=a[i-1]) swap(a[i], a[i+1]);
          }
          begin--;
      }
  }
  
  int main(void) {
      int n = 6;
      int a[6] = {9, 3, 7, 4, 5, 6};
  
      printArray(a, n);
      sharkSort(a, n);
      printArray(a, n);
  }

Prednáška 8

Organizačné poznámky

DÚ4 do piatka, zadania DÚ5 sa objavia koncom týždňa
Zadania PDÚ2 tento týždeň
Zajtra začneme preberať rekurziu, dôležité učivo

Z minulej prednášky

Vďaka znakom môžeme skúsiť urobiť prvú jednoduchú kontrolu toho, čo nám vlastne používateľ napísal na vstup. Napríklad, či zadal správne celé číslo a nenamiešal medzi cifry nejaký iný znak.

#include <iostream>
using namespace std;

int main(void) {
    int N = 0;
    char c;

    cout << "Zadajte cele kladne cislo: ";

    cin >> noskipws >> c;
    while ((c >= '0') && (c <= '9')) { // kym je nacitany znak cislo (t.j. jedna cifra)
        /* vsimnite si ze nepripocitavame priamo c ale c-'0': ide totiz o kod znaku a '0' ma kod 48 */
        N = N * 10 + (c - '0'); // upravime cislo N
        cin >> noskipws >> c; // a nacitame dalsi znak
    }

    if ((c == ' ') || (c == '\n')) { // ak sme skoncili medzerou alebo koncom riadku, tak je to pekne cislo
        cout << "Zadali ste " << N << endl;
    } else {
        cout << "Toto je cele cislo?" << endl; // ak sme skoncili niecim divnym, tak to asi nebude ok
    }
}

Reťazec ako postupnosť znakov

Reťazec je nejaký text, postupnosť znakov
Vedeli by sme si naprogramovať vlastné funkcie na prácu s reťazcami, ukladať ich ako pole znakov
Napríklad funkcia nacitajRiadok, ktorá znak po znaku načíta text z konzoly a uloží ich do poľa, dĺžku text uloží do premennej n.
Naopak funkcia vypisRetazec dostane pole znakov a jeho dĺžku a vypisuje znak po znaku.

#include <iostream>
using namespace std;

void nacitajRiadok(char a[], int &n, int maxN) {
    /* Z konzoly nacita riadok a ulozi ho do pola a,
     * jeho dlzku do premennej n. Premenna maxN 
     * obsahuje dlzku pola, ktoru nesmieme prekrocit. 
     * Ak je riadok dlhsi ako maxN, nacita sa z neho iba cast. */
    n = 0;
    while(n<maxN) {
        cin >> noskipws >> a[n];
        n++;
        if(a[n-1]=='\n') { break; }
    }
}

void vypisRetazec(char a[], int n) {
    /* Na konzolu vypise prvych n znakov z pola a */
    for(int i=0; i<n; i++) {
        cout << a[i];
    }
}

int main(void) {
    const int maxN = 100;
    char a[maxN];
    int n;
       
    cout << "Zadajte text: ";
    nacitajRiadok(a, n, maxN);
    cout << "Zadali ste: ";
    vypisRetazec(a, n);
}

Nevýhoda tohto riešenia: reťazec musíme posielať všade ako dve premenné (pole a dĺžku)
Preto v Cčku reťazce štandardne fungujú trochu inak.

Reťazce v jazyku C

Textový reťazec je v jazyku C štandardne uložený ako postupnosť znakov char v poli ukončená znakom s kódom 0.

Nemusíme teda ukladať zvlášť dĺžku, reťazec ide po prvú nulu
Pozor, rozdiel medzi znakom s kódom 0 a znakom '0' s kódom 48
Reťazce teda nemôžu obsahovať vo vnútri znak s kódom 0, ten je rezervovaný na ukončovanie
Na reťazec s n znakmi potrebujeme pole dĺžky aspoň n+1, lebo jeden znak sa minie na ukončovací symbol

Teraz by sme vedeli prepísať nacitajRiadok a vypisRetazec, ale netreba, lebo existujú v knižniciach

Inicializácia reťazcov

Chceme vytvoriť premennú str obsahujúce reťazec Ahoj spolu s koncom riadku
Prvý spôsob je zdĺhavý:

    char str[10];
    str[0] = 'A';
    str[1] = 'h';
    str[2] = 'o';
    str[3] = 'j';
    str[4] = '\n'; // znak pre koniec riadku
    str[5] = 0;

Alebo ako inicializácia poľa: char str[10]={'A','h','o','j','\n',0};
Špeciálna skratka: char str[10]="Ahoj\n";

Ako vytvoríme prázdny reťazec?

Reťazec je naozaj pole

Znaky reťazca môžeme meniť

char a[100] = "vlk";
char ch = a[0]; // ch obsahuje hodnotu 'v'
char b[100] = "pes";

b[0] = ch;     // priradíme do jedného prvku reťazca premmennú typu char. Výsledkom je 'ves'.
b[0] = 'd';    // priradíme do jedného prvku reťazca konštantný znak. Výsledkom je 'des'. 
b[0] = a[1];   // priradíme do jedného prvku reťazca prvok iného reťazca. Výsledkom je 'les'.

Reťazec sa nedá kopírovať jednoduchým priradením, nemôžeme teda spraviť

char a[100];
a = "Ahoj";           // chyba
char b[100] = "Ahoj"; // ok - inicializacia
a = b;                // chyba

Reťazce sa nedajú ani porovnávať pomocou ==, !=, < atď

Kopírovanie a porovnávanie si musíme naprogramovať cez cykly, alebo použiť hotové funkcie z knižníc.

Knižnica cstring

Obsahuje mnohé funkcie na prácu s reťazcami, napríklad tieto:

strlen(retazec): vráti dĺžku reťazca
strcpy(kam, co): skopíruje reťazec co do reťazca kam (pole kam musí byť dosť dlhé)
strcat(kam, co): za koniec reťazca kam pridá reťazec co (pole kam musí byť dosť dlhé)
strcmp(retazec1, retazec2): vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a".

Všetky tieto funkcie by sme si však vedeli naprogramovať aj sami. Tu je napríklad výpočet dĺžky:

int myStrLen(char a[]) {
    int n=0; 
    while(a[n]!=0) {  n++; }
    return n;
}

čo bude funkcia robiť ak reťazcu chýba na konci 0?

Dve verzie kopírovania:

void myStrCpy(char a[], char b[]) {
    /* Skopiruj obsah retazca b do retazca a.
     * Pole a musi mat dost miesta. */
    int n = 0;
    while (b[n] != 0) {
        a[n] = b[n];
        n++;
    }
    a[n] = 0; // reťazec musí končiť 0
}

void myStrCpy2(char a[], char b[]) {
    /* Skopiruj obsah retazca b do retazca a.
     * Pole a musi mat dost miesta. */
    for (int i = 0; i <= strlen(b); i++) {
        a[i] = b[i];
    }
}

Ktorá je rýchlejšia pre dlhé reťazce?
Aká je ich zložitosť ako funkcia dĺžky reťazca n?

Namiesto strcmp naprogramujeme len test na rovnosť:

bool rovnostRetazcov(char a[], char b[]) {
    /* vrati true ak su retazce a, b rovnake, inak vrati false */

    for (int i = 0; a[i] != 0 || b[i] != 0; i++) {
        if (a[i] != b[i]) return false;
    }
    return true;
}

Ako bude prebiehať funkcia, ak jeden reťazec je začiatkom druhého?

Načítavanie a vypisovanie reťazcov

Bežné načítanie z konzoly do reťazca (cin >> str) načíta jedno slovo
- Preskočí biele znaky (medzery, konce riadkov, tabulátory), potom prečíta všetko po ďalší biely znak (alebo koniec vstupu) a uloží do premennej.
- Pri čítaní je vhodné nastaviť maximálny počet znakov na načítanie, aby sme nevyšli z poľa

Na načítanie jedného riadku je možné použiť funkciu getline. Načíta až po koniec riadku, ten zahodí.
Vypisovanie funguje normálne pomocou cout << str

#include <iostream>
using namespace std;

int main(void) {
    const int maxN = 100;
    char str[maxN], str2[maxN], str3[maxN];

    cin.getline(str, maxN); // cely riadok, ale najviac maxN-1 znakov

    cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní
    cin >> str2;     // nacita jedno slovo
    cin.width(maxN); // najviac maxN-1 znakov pri najbližšom načítaní
    cin >> str3;     // nacita dalsie slovo

    cout << "str: \"" << str << "\"" << endl;
    cout << "str2: \"" << str2 << "\"" << endl;
    cout << "str3: \"" << str3 << "\"" << endl;
}

Príklad behu programu (prvé dva riadky zadal užívateľ, na začiatku a konci každého je medzera)

 a b c 
 g h i 
str: " a b c "
str2: "g"
str3: "h"

Algoritmy s reťazcami

Prácu s reťazcami si precvičíme na niekoľkých menších príkladoch.

Vyhľadávanie podreťazca

Chceme zistiť, či a kde sa v reťazci nachádza určité slovo alebo iná vzorka.

#include <iostream>
#include <cstring>
using namespace std;

int find(char text[], char pattern[]) {
    /* Vráti -1 ak sa reťazec pattern nevyskytuje v reťazci text,
     * inak vráti polohu jeho prvého výskytu. */

    int n = strlen(text);
    int m = strlen(pattern);
    for (int i = 0; i < n - m + 1; i++) {
        int j = 0;
        while (j < m && text[i + j] == pattern[j]) {
            j++;
        }
        if (j == m) {
            return i;
        }
    }
    return -1;
}

int main(void) {
    const int maxN = 2000;
    char A[maxN], B[maxN];

    cout << "Zadaj text: ";
    cin.getline(A,maxN);
    cout << "Zadaj vzorku: ";
    cin.getline(B,maxN);
    cout << find(A,B) << endl;
}

Predpočítame si dĺžky a uložíme do premenných, aby sa zbytočne nerátali znova a znova
Vedeli by sme do poľa uložiť polohy všetkých výskytov?

Prevod čísla na reťazec

Máme danú premennú x typu int, chceme ju uložiť v desiatkovej sústave do reťazca.

Zvyšok po delení 10 je posledná cifra, uložíme si ju do reťazca, vydelíme x desiatimi
Opakujeme, kým nespracujeme celé číslo.
Prevod z čísla c (0..9) na cifru: '0'+c
Nezabudneme na ukončovací znak 0
Dostaneme číslo v opačnom poradí, napr pre x=12 budeme mať reťazec {'2', '1', 0}
Preto ešte celé číslo otočíme naopak.

void reverse(char a[]) {
    int n = strlen(a);
    int i = 0;
    int j = n - 1;
    while (i < j) {
        char tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;
        i++; j--;
    }
}

void int2str(int x, char a[]) {
    /* prevedie kladne cele cislo x na retazec,
     * vysledok ulozi do retazca a, ktory musi mat dost miesta. */
    assert(x > 0);

    int n = 0;
    while(x > 0) {
        a[n] = '0' + x % 10;
        x /= 10;
        n++;
    }
    a[n] = 0;

    /* teraz je cislo naopak, treba otocit */
    reverse(a);
}

Ako upravíme funkciu, aby fungovala aj pre x=0, prípadne záporné x?
Pozor na rozdiel medzi znakom 0 a '0' (a medzi reťazcom "0")

Formátovanie čísla

Chceme číslo zapísať do reťazca a doplniť naľavo medzerami na šírku width.

const int maxN = 100;

void formatInt(int x, char A[], int width) {
    /* číslo x konvertujeme na reťazec
     * a uložíme do poľa A zarované doprava na šírku width */

    /* najprv x uložíme do pomocného reťazca B  a zrátame jeho dĺžku n */
    char B[maxN];
    int2str(x, B);
    int n = strlen(B);

    /* do A dáme n-width medzier a ukončovaciu 0 */
    assert(n <= width);
    int i;
    for (i = 0; i < width - n; i++) {
        A[i] = ' ';
    }
    A[i] = 0;

    /* za A prikopírujeme B */
    strcat(A, B);
}

Čo by sa stalo, ak by sme nedali do A ukončovaciu 0?
Vedeli by sme prepísať program, aby pracoval priamo v poli A (bez poľa B)?

Využijeme na vypísanie pekne zarovnanej tabuľky faktoriálov:

int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

int main(void) {
    char A[maxN];
    int n = 12;
    for (int i = 1; i <= n; i++) {
        int x = factorial(i);
        formatInt(i, A, 2);
        cout << A << "! = ";
        formatInt(x, A, 10);
        cout << A << endl;
    }
}

 1! =          1
 2! =          2
 3! =          6
 4! =         24
 5! =        120
 6! =        720
 7! =       5040
 8! =      40320
 9! =     362880
10! =    3628800
11! =   39916800
12! =  479001600

Dalo by sa aj jednoduchšie pomocou nastavenia width v cin:

int main(void) {
    int n = 12;
    for (int i = 1; i <= n; i++) {
        int x = factorial(i);
        cout.width(2);
        cout << i << "! = ";
        cout.width(10);
        cout << x << endl;
    }
}

Zalamovanie riadkov

Máme reťazec s nejakým textom, v ktorom sa vyskytujú rôzne biele znaky, napríklad medzery a konce riadkov. Máme danú šírku riadku W, napr. 80 znakov. Úlohou je ho upraviť tak:
- aby na každom riadku bolo najviac napr. W znakov, pričom nový riadok začína tam, kde by už ďalšie slovo presahovalo cez W
- medzi dvoma slovami má byť vždy buď jedna medzera alebo jeden koniec riadku
- predpokladáme, že žiadne slovo nemá viac ako W znakov

Zadavaj text ukonceny prazdnym riadkom.
A AA A AAA 
A  A AA AAA
AAA A AA AA  A

Zadaj sirku riadku:
5
Sformatovany odstavec:
A AA
A AAA
A A
AA
AAA
AAA A
AA AA
A

Zadavaj text ukonceny prazdnym riadkom.
Martin Kukucin: Do skoly.    Vakacie sa koncia. Ondrej Rybar sa vse zamysli nad marnostou sveta i vsetkeho, co je v nom. 
Predstupuje mu tu i tu pred oci profesor, ako stoji pred ciernou tabulou, drziac kruzidlo v ruke a demonstruje pamatnu poucku Pytagorovu. 
A zimomriavky naskakuju na chrbat, lebo s geometriou stoji od pociatku na nohe valecnej. 
Ani matematika nenie lepsia, menovite odvtedy, co sa do nej vplichtili miesto cisel vsakove litery. 
Neraz hutal, naco ich ucenci vpustili do matematiky - ved i bez nich je dost strapata: ci sa im malilo cisel a tak preto vsantrocili medzi ne a a b a ci fantazia sa im tak rozihrala, 
ze prekrocila hranice cisel celych, zlomkov obycajnych i desatinnych i bohvieakych, a zabludila na nivy, kde rastu nestastne litery? 
 ,Uz akokolvek,' huta Ondro, ,litery tam nemaju co hladat. Tazko je uverit, ze a/b = c, lebo nevies, co je a, alebo b.' 

Zadaj sirku riadku:
50
Sformatovany odstavec:
Martin Kukucin: Do skoly. Vakacie sa koncia.
Ondrej Rybar sa vse zamysli nad marnostou sveta i
vsetkeho, co je v nom. Predstupuje mu tu i tu pred
oci profesor, ako stoji pred ciernou tabulou,
drziac kruzidlo v ruke a demonstruje pamatnu
poucku Pytagorovu. A zimomriavky naskakuju na
chrbat, lebo s geometriou stoji od pociatku na
nohe valecnej. Ani matematika nenie lepsia,
menovite odvtedy, co sa do nej vplichtili miesto
cisel vsakove litery. Neraz hutal, naco ich ucenci
vpustili do matematiky - ved i bez nich je dost
strapata: ci sa im malilo cisel a tak preto
vsantrocili medzi ne a a b a ci fantazia sa im tak
rozihrala, ze prekrocila hranice cisel celych,
zlomkov obycajnych i desatinnych i bohvieakych, a
zabludila na nivy, kde rastu nestastne litery? ,Uz
akokolvek,' huta Ondro, ,litery tam nemaju co
hladat. Tazko je uverit, ze a/b = c, lebo nevies,
co je a, alebo b.'

Plán: úlohu si rozdelíme na viac častí

Prerobíme reťazec tak, aby sme všetky biele znaky nahradili medzerami. Na rozpoznanie bielych znakov použijeme funkciu isspace z knižnice cctype.
Každý súvislý úsek medzier nahradíme práve jednou medzerou, zmažeme medzery na začiatku a konci.
- Podobá sa na príklad s vyhadzovaním núl z poľa z cvičení
- Viac možností na riešenie, napríklad znaky presýpame do nového poľa. My ale použijeme len jedno pole
Niektoré medzery nahradíme koncom riadku, aby každý riadok mal šírku najviac W.
Spravíme načítanie a vypísanie.

#include <iostream>
#include <cstring>
#include <cctype>
#include <cassert>
using namespace std;

void simplify(char A[]) {
    /* V retazci A nahradi kazdy suvisly usek bielych znakov prave jednou medzerou.
     * Na zaciatku a konci retazca nebudu medzery. */

    int i;

    /* prepis hocijake biele znaky na medzeru */
    for (int i = 0; A[i] != 0; i++) {
        if (isspace(A[i])) {
            A[i] = ' ';
        }
    }

    int kam = 0; /* prve este neobsadene miesto */
    char prev = ' '; /* predchadzajuci znak */

    for (int i = 0; A[i] != 0; i++) {
        /* ak nemame viac medzier po sebe, skopirujeme znak */
        if (A[i] != ' ' || prev != ' ') {
            A[kam] = A[i];
            kam++;
        }
        /* zapamatame si posledny znak */
        prev = A[i];
    }

    /* zrusime pripadnu medzeru na konci */
    if (kam > 0 && A[kam - 1] == ' ') {
        kam--;
    }

    /* retazec ukoncime nulou */
    A[kam] = 0;
}

bool breakLines(char A[], int width) {
    /* Preformatuje odstavec na sirku riadku width, vyhodi zbytocne medzery.
     * Dlzka kazdeho slova musi byt najviac width, inak funkcia vrati false */

    simplify(A);
    int n = strlen(A);

    int zac = 0;  /* prve pismeno v riadku */
    while (zac < n) {
        int kon = zac + width;  /* potencialny koniec riadku */
        /* ak uz nemame dost pismen na cely riadok */
        if (kon > n) {
            kon = n;
        }
        /* ak sme na konci, pridame koniec riadku za koniec retazca */
        if (kon == n) {
            A[kon] = '\n';
            A[kon + 1] = 0;
            n++;
        } else {
            /* ideme späť, kým nenájdeme medzeru */
            while (kon > zac && A[kon] != ' ') {
                kon--;
            }
            /* nenašli sme medzeru: slovo bolo príliš dlhé. */
            if (kon == zac) {
                return false;
            }
            /* medzeru prepíšeme na koniec riadku */
            assert(A[kon]==' ');
            A[kon] = '\n';
        }
        /* za koncom riadku bude novy zaciatok */
        zac = kon + 1;
    }
    return true;
}

int main(void) {
    const int maxN = 2000;
    char A[maxN];

    cout << "Zadavaj text ukonceny prazdnym riadkom." << endl;
    while (true) {
        /* nacitame jeden riadok */
        char tmp[maxN];
        cin.getline(tmp, maxN);
        /* ak je prazdny, koncime nacitavanie */
        if (strcmp(tmp, "") == 0) {
            break;
        }
        /* ak je miesto v poli A, pridame do neho novy riadok */
        if (strlen(A) + strlen(tmp) + 2 < maxN) {
            strcat(A, tmp);
            strcat(A, "\n");
        } else {
            cout << "Text je prilis dlhy." << endl;
            return 1;
        }
    }

    cout << "Zadaj sirku riadku:" << endl;
    int width;
    cin >> width;

    breakLines(A, width);
    cout << "Sformatovany odstavec:" << endl;
    cout << A;
}

Akú zložitosť má načítanie vzhľadom na celkový počet načítaných písmen? Dalo by sa zlepšiť?

Zhrnutie

Reťazec je pole znakov, za posledným znakom reťazca dáme špeciálny znak s kódom 0
V knižnici cstring sú funkcie na porovnávanie a kopírovanie reťazcov atď.
Ďalšie funkcie si vieme naprogramovať aj sami, zvyčajne jednoduchá práca s poľom

Prednáška 9

Organizačné poznámky

DÚ4 do piatka, zadania DÚ5 sa objavia koncom týždňa (odovzdávať sa bude až po sviatkoch)
Zadania PDÚ2 tento týždeň
Záverečný test bude v piatok 13.12. o 14:00 v posluchárni B
Opisovanie na domácich úlohách

Bežné úvodné príklady na rekurziu

Vysvetlenie pojmu rekurzia sa dá zhrnúť do jednej vety: Rekurzia je metóda, pri ktorej definujeme objekt (funkciu, pojem, . . . ) pomocou jeho samého.

Na začiatok sa skúsme pozrieť na „klasické“ príklady algoritmov využívajúcich rekurziu. Prvým, azda najklasickejším príkladom je faktoriál. Ten pre prirodzené (0, 1, 2, . . .) číslo n vráti 1 pokiaľ n = 0 a súčin všetkých čísel od 1 po n inak.

int factorial(int n){
    if (n<2) return 1;
    else return n*factorial(n-1);
}

Výpočet faktoriálu je založený na jeho rekurzívnej definícii. Pri prepisovaní rekurzívnych definícii (a všeobecne pri používaní rekurzie) je potrebné dodržiavať nasledujúce zásady, aby sme sa vyhli chybám:

Príkazová časť rekurzívnej procedúry (funkcie) musí obsahovať vetvu pre triviálny prípad niektorého základného parametra alebo vstupnej hodnoty. Táto vetva nebude obsahovať (rekurzívne) volanie procedúry (funkcie), ktorú práve definujeme.
Ľubovoľné volanie procedúry (funkcie) vo vnútri jej príkazovej časti musí mať vhodne redukovaný argument (alebo globálnu hodnotu). Pri tejto redukcii sa očakáva, že raz dosiahne triviálny prípad po konečnom počte opakovaní.

Ďalším tradičným príkladom na rekurziu s ktorým ste sa už stretli je počítanie najväčšieho spoločného deliteľa. Opäť dostvame jednoduchú rekurzívnu funkciu. Budeme si jej parametre udržovať usporiadané, tj. prvý parameter je vždy väčší ako druhý (ak by to tak nebolo, vieme jednuduchým testom na začiatku upraviť).

Triviálny prípad nastáva, keď druhý parameter je 0. Potom je výsledkom prvý parameter.
V opačnom prípade je NSD(a,b) = NSD(a mod b, b) - tu však vidíme, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle a mod b < b} a preto zavoláme NSD(b,a mod b)

int nsd(int a, int b){
 if (b == 0) return a;
 else return nsd(b,a%b);
}

A nemôžeme vynechať obľúbený rekurzívny príklad - Fibonacciho čísla. Tam sa rekurzia priam pýta, keďže Fibonacciho čísla sú samé o sebe definované rekurzívne.

F(0)=F(1)=1
F(n)=F(n-1)+F(n-2) pre n>2

Z tejto definície vieme opäť urobiť rekurzívny príklad jednoducho:

int fib(int n){
    if (n<2) return 1;
    else return fib(n-1)+fib(n-2);
}

Nepriama rekurzia

Všetky doteraz uvedené funkcie sú príkladom priamej rekurzie – definovaná funkcia používa seba samú priamo. Druhým možným prípadom je nepriama rekurzia (alebo tiež vzájomná), kedy funkcia neodkazuje vo svojej definícii priamo na seba, ale využíva inú funkciu, ktorá sa odkazuje naspäť na prvú (všeobecnejšie sa kruh môže uzavrieť na krokov viac). Ako príklad uveďme rekurzívne definície predikátov párnosti a nepárnosti

bool even(int n) {
    if (n == 0) return true;
    else return odd(n - 1);
}

bool odd(int n) {
    if (n == 0) return false;
    else return even(n - 1);
}

Binárne vyhľadávanie

Binárne vyhľadávanie sme už mali skôr, avšak rekurzia značne zjednoduší a zprehľadní túto funkciu. Na rozdiel od pôvodnej verzie si nepotrebujeme pamätať okraje aktuálneho miesta - pamätá si ich za nás rekurzia (ako svoj parameter).

Ako funguje:

V prípade, že už máme jednoprvkové pole dostávame triviálny prípad.
Ak máme viac prvkov, tak sa rekurzívne zavoláme na pravú alebo ľavú stranu podľa vzťahu hodnoty x a stredného prvku.

bool binSearch(int x, int l, int r, int A[]){
    if (l==r) return (A[l]==x);
    if (x<=A[(l+r)/2]) return binSearch(x,l,(l+r)/2,A);
    else return binSearch(x,(l+r)/2+1,r,A);
}

int main(void){
    int A[9]={1,5,7,12,45,79,100,123,467};
    cout << binSearch(7,0,8,A);
}

Rekurzia

Predchádzajúce príklady boli príkladmi použitia rekurzie pri definícii jednoduchých funkcií. Samozrejme, funkcie, ktoré by počítali to isté, by sa dali naprogramovať aj bez pomoci rekurzie. Ale pravdepodobne vidíte, že rekurzívny spôsob je prehľadnejší, zrozumiteľnejší, kratší a krajší (teda aspoň v prvých príkladoch určite).

Načo to vôbec robíme, veď všetko toto sme už robili aj pred tým a nebolo to nič náročné (prečo vôbec riešiť niečo ako rekurzia)? Asi hlavný dôvod je, že nie všetko vieme prepísať bez rekurzie. Príklady, ktoré sme ukázali boli teda istým spôsobom ľahké - pomocou rekurzie vieme urobiť oveľa viac.

Vyhodnocovanie výrazu

Máme zadaný reťazec, v ktorom je výraz obsahujúci celé čísla, znamienka '+', '-' a zátvorky. Pre jednoduchosť predpokladajme, že zátvorky sú všade (t.j. každý výraz je tvaru (Výraz Operátor Výraz) alebo Číslo)a celý výraz je správne uzátvorkovaný.

Príklady výrazov:

99
(12+13)
(((12-5)+7)-(6+8))

Na vyhodnotenie výrazu môžeme použiť nasledovný postup:

Nájdeme si znamienko Z také, že výraz je tvaru ((Výraz1)Z(Výraz2))
Zistíme, akú hodnotu majú Výraz1 a Výraz2
Hodnota celého výrazu sa dá vypočítať pomocou týchto hodnôt a znamienka Z

Čo nutne ešte potrebujeme je nájsť správne znamienko Z.

int najdiZnamienko(char str[]){
    /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/
    int poc=0;
    for (int i=1; i<strlen(str)-1; i++){
        if (str[i]=='(') poc++;
        else if (str[i]==')') poc--;
        else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i;
    }
    return -1;
}

Ďalej je dobre sa zamyslieť, kedy s vyhodnocovaním skončíme. Bude to v prípade, že už očakvame, že máme výraz iba celé číslo - na začiatku nie je zátvorka.

Potom vyhodnocovanie výrazu može pracovať nasledovne:

int vyhodnotVyraz(char str[]){
    if (str[0]!='(') return vyhodnotCislo(str);
    else {
        char s[100];
        int poz, hodnota1, hodnota2;

        poz=najdiZnamienko(str);

        strCopy(str,s,1,poz-1);      // od 1 po pozíciu pred znamienkom (pozícia 0 je '(' )
        hodnota1=vyhodnotVyraz(s);
        strCopy(str,s,poz+1,strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' )
        hodnota2=vyhodnotVyraz(s);

        switch (str[poz]){
            case '+': return hodnota1+hodnota2;
            case '-': return hodnota1-hodnota2;
        }

        return 0;
    }    
}

Fraktály

Kochova krivka stupňa 3

Príkladom fraktálu je Kochova krivka. Ako vzniká?

Predstavme si úsečku, ktorá meria d centimetrov.
Ďalej potrebujeme transformáciu, teda konkrétne presne definovaný súbor opakovateľných pravidiel: Úsečka sa rozdelí na tretiny a nad strednou tretinou sa zostrojí rovnostranný trojuholník. Základňa trojuholníka v krivke nebude. Opakovaní môžeme robiť nekonečno.
Druhá možnosť je popísať krivku pomocou systému, ktorého vykonávanie sa podobá príkazom korytnačky.
- Základným krokom je F (forward) vytvorenie rovnej čiary určitej dĺžky
- Okrem toho poznáme príkazy + a - (turn left a turn right o určitý uhol - v našom prípade 60 stupňov)
- Krivku môžeme popísať pomocou nasledovného pravidla F → F+F--F+F , ktoré kreslí z pôvodnej krivky komplikovanejšiu krivku.
- Takže namiesto F (rovnej čiary určitej dĺžky) môžeme nakresliť rovnú čiaru, otočiť sa doľava, nakresliť rovnú čiaru, dva krát sa otočiť doprava, nakresliť čiaru, otočiť sa doľava a nakresliť čiaru.
- Následne s každou čiarou môžeme opäť urobiť transformáciu a dostať zložitejšiu krivku.
- Drobný problém, ktorý musíme vyriešiť je, že týmto spôsobom (ak by sme robili vždy čiary veľkosti d) by nám obrázok príliš rástol. My však chceme ostať v pôvodnej veľkosti preto pri každej transformácii zmenšíme dĺžku čiary na 1/3.

Z toho potom dostávame nasledovný program:

 
#include "../SVGdraw.h"

void drawKoch(double d, int n, Turtle& turtle){
    if (n==0) turtle.forward(d);
    else {
        drawKoch(d/3, n-1, turtle);
        turtle.turnLeft(60);
        drawKoch(d/3, n-1, turtle);
        turtle.turnLeft(-120);
        drawKoch(d/3, n-1, turtle);
        turtle.turnLeft(60);
        drawKoch(d/3, n-1, turtle);
    }
}

int main(void) {
    int width = 310; /* rozmery obrazku */
    int height = 150;

    double d = 300; /* velkost krivky */
    int n = 5; /* stupen krivky */

   /* Vytvor korytnačku otočenú doprava. */
   Turtle turtle(width, height, "fraktal.svg", 1, height-10, 0);

    /* nakresli Kochovu krivku rekurzívne */
    drawKoch(d, n, turtle);

    /* Schovaj korytnačku. */
    turtle.finish();
}

Hanojské veže

Problém hanojských veží pozostáva z troch stĺpcov (tyčiek) a niekoľkých kruhov rôznej veľkosti. Začína sa postavením pyramídy z kruhov (kameňov) na prvú tyčku.
Úlohou je potom presunúť celú pyramídu na inú tyčku, avšak pri dodržaní nasledovných pravidiel:
- v jednom ťahu (na jedenkrát) je možné premiestniť iba jeden hrací kameň
- väčší kameň nesmie byť nikdy položený na menší

Ako budeme úlohu riešiť? Asi rekurzívne, nie?

V prípade, že máme iba jeden kameň je úloha veľmi jednoduchá - preložíme ho z pôvodného stĺpika na cieľový stĺpik.
Ak chceme preložiť viac kameňov (nech ich je N), tak
- Všetky okrem posledného preložíme na pomocný stĺpik (na to použijeme taký istý postup len s N-1 kameňmi)
- Premiestnime jeden kameň kam potrebujeme
- Zatiaľ odložené kamene (na pomocnom stĺpiku) preložíme z pomocného na cieľový stĺpik (na to použijeme opäť taký istý postup s N-1 kameňmi)

Aby sme to popísali konkrétnejšie - preloženie N kameňov z A na C (s pomocným stĺpikom B) urobíme takto:

Preložíme N-1 kameňov z A na B (s použitím C)
Preložíme 1 kameň z A na C (s použitím B - ale reálne to potrebovať nebudeme)
Preložíme N-1 kameňov z B na C (s použitím A)

Dôležité je si uvedomiť, že nasledovný postup dodržuje pravidlá.

void presunHanoi(int odkial, int cez, int kam, int n){
    if (n == 1) {
        cout << "Prelozim kamen z " << odkial <<" na " << kam << endl;
    } else {
        presunHanoi(odkial, kam, cez, n-1); // odlozime si n-1 na pomocny-cez
        presunHanoi(odkial, cez, kam, 1);   // prelozime najvacsi na finalne miesto
        presunHanoi(cez, odkial, kam, n-1); // zvysnych n-1 prelozime z docasneho odkladiska na finalne
    }
}

int main (void){
    presunHanoi(1, 2, 3, 3); // z veze 1 na vezu 3 (pomocou veze 2)
}

Rekurzia pomocou stacku - ako to funguje

O rekurzívne volania sa stará zásobník. Ako funguje?

Pri vnáraní sa do rekruzívnej funkcie (keď volá funkcia sama seba) si potrebuje zapamätať stav v akom sa nachádza, aby sa pri vynorení vedel dostať do pôvodného stavu. Všetky informácie popisujúce stav si zapíše do zásobníka a až potom sa rekurzívne zavolá.
Pri vynorení musí zo zásobníka vybrať v prvom rade miesto, kde v rekurzívnej funkcii pokračovať a ďalej všetky premenné.

Čo si teda musel zásobník pamätať?

adresu návratu - teda miesto kde v rekurzívnej funkcii sa nachádza: dôležité je to hlavne v situácii, keď máme viacero rekurzívnych volaní (či už podľa podmienky alebo sa voláme vždy viac krát)
lokálne premenné - hodnoty (a spôsob ako sa k nim dostať - v realite totiž zásobník funguje kúsok komplikovanejšie)

Keď už vieme, že o rekurzívne volania sa stará zásobník, možeme si taký jednoduchý zásobník osimulovať napríklad na výpočte faktoriálu.

int fact(int n){
    if (n<2) return 1;
    else return n*fact(n-1);
}

Chvostová rekurzia

Dôvod, prečo sme tieto príklady vedeli napísať už pred tým, ako sme sa dozvedeli niečo o rekurzii je to, že voláme rekurziu z každého volania iba raz. Napríklad na výpočet faktoriálu daného čísla potrebujeme jedenkrát rekurzívne zavolať faktoriál predchádzajúceho čísla. Navyše sa rekurzívne volanie nachádza iba ako posledný krok (niektorých vetiev) výpočtu funkcie. Dobrý kompilátor dokáže z takejto rekurzívnej funkcie vytvoriť nerekurzívnu.

A Fibonacci, ten sa predsa volá dve krát? Áno, ale iba ak je program napísaný neefektívne. Ak napíšeme program podľa uvedeného predpisu a pokúsime sa funkciu volať s rôznymi parametrami, tak čoskoro zistíme, že takto deﬁnovaná funkcia počíta celkom pomaly. Prečo? Jednotlivé hodnoty Fibonacciho čísel počítame totiž viackrát (čím menšie číslo, tým viackrát je spočítané). To sa dá napraviť celkom jednoducho použitím takzvaného akumulátora. Akumulátor je dodatočný parameter, v ktorom si predávame stav výpočtu. Konkrétne pri efektívnejšom počítaní Fibonacciho čísel zdola nahor si v akumulátore budeme odkladať posledné dve napočítané čísla. V podstate takto budeme napodobňovať to, ako by ste si napočítali konkrétne Fibonacciho číslo v hlave. Začnete od dvoch jednotiek a postupne si dopočítate ďalšie až po číslo, ktoré ste potrebovali.

int fib1(int a, int b, int n) {
    if (n == 0) return a;
    else return fib1(b,a+b,n-1);
}

int fib(int n){
    fib1(1,1,n);
}

V parametroch a a b si pamätáme dve susedné čísla a v parametri n si pamätáme, koľko rekurzívnych volaní ešte chceme urobiť. Takže takto naprogramovaná Fibonacciho funkcia je nielen rýchla, ale aj kopíruje spôsob nášho uvažovania, a preto je zrozumiteľnejšia. Navyše používa iba jedno rekurzívne volanie.

Cvičenia 5

Funkcie zo string.h

Naprogramujte si vlastné verzie funkcií z knižnice cstring:

myStrCat(kam, co): za koniec reťazca kam pridá reťazec co (pole kam musí byť dosť dlhé)
myStrCmp(retazec1, retazec2): vráti nulu ak sa reťazce rovnajú, kladné číslo keď je prvý neskôr v abecednom poradí, záporné číslo ak je skôr. Pozor, to či je skôr alebo neskôr sa berie podľa kódov znakov, takže napr "Z" je skôr ako "a".

Použitie strcmp:

Načítajte od užívateľa postupne 5 slov a vypíšte z nich to, ktoré je prvé v abecednom poradí. Na porovnávajte reťazcov použite strcmp (alebo myStrCmp). Použite iba dve polia char-ov, v jednom budete mať práve načítané slovo, v druhom doteraz najmenšie nájdené.

Práca s reťazcami

Upravte reťazec tak, aby začiatočné písmeno každého slova bolo veľké (môžete použiť funkciu toupper z knižnice cctype).
Upravte načítané slovo nasledovne: Prvý a posledný znak slova necháme, ostatné náhodne poprehadzujeme.
- Vypíšte používateľovi takto upravené slovo a dajte mu hádať aké slovo ste pôvodne mali.

Jednoduchá kalkulačka

Napíšte program, ktorý načíta dve čísla a ponúkne "Menu" operácií, ktoré s nimi môže vykonať (plus, mínus, krát, deleno). Na základe znaku, ktorý používateľ zadal, vypíše výsledok.
Rozšírte program tak, aby sa vždy po skončení pýtal, či ešte chce používateľ ďalej pokračovať.

Veľké čísla

Vytvorte program pre prácu s dlhými číslami. Čísla si reprezentujte v poli celých čísel, ktoré zodpovedá desiatkovému zápisu veľkého čísla.

Vytvorte funkciu pre načítanie takéhoto čísla. Funkcia prečíta reťazec znakov a uloží ho do poľa reprezentujúceho toto číslo.
Vytvorte funkciu pre vypísanie takéhoto čísla. Funkcia vypíše reťazec znakov na základe obsahu poľa.
Vytvorte funkciu pre sčítanie dvoch takto reprezentovaných čísel. Výsledkom je tretie pole, ktoré reprezentuje výsledok sčítania.

Zmeny programov z prednášky

V programoch z prednášky 8 spravte nasledujúce zmeny:

Funkciu find na hľadanie vzorky v texte prerobte tak, aby našla všetky výskyty, vrátila ich pozície v poli a vrátila ich počet ako návratovú hodnotu
Funkciu formatInt na formátovanie čísla na určitú šírku stĺpca prerobte tak, aby nepoužívala pomocné pole B, ale všetko robila priamo v poli A

Prednáška 10

Oznamy

DÚ5 odovzdávajte do pondelka 4.11. 22:00.
Pokročilú DÚ2 odovzdávajte do piatka 8.11. 22:00.
V priebehu týždňa zverejníme DÚ6
Záverečný test bude v piatok 13.12. o 14:00 v posluchárni B (pozor, zmena času)
Tento štvrtok je rektorské voľno. Ak máte záujem aj vo štvrtok tak absolvovať nepovinné cvičenia, ozvite sa B. Brejovej emailom najneskôr v stredu poobede. Ak sa nikto neozve, cvičenia nebudú.

Opakovanie rekurzie

Kochova krivka stupňa 3

Rekurentná definícia: určitý objekt definujeme pomocou menších objektov toho istého typu
- Napr. Fibonacciho čísla F(n) = F(n-1) + F(n-2)
- Napr. fraktál stupňa n ako kompozícia fraktálov stupňa n-1
- Nezabudnime na triviálne prípady, napr. F(0)=F(1)=1, fraktál stupňa 0

Rekurentné definície vieme často priamočiaro zapísať do rekurzívnych funkcií (aj keď môžu byť pomalé)

int fib(int n) {
    if (n<2) return 1;
    else return fib(n-1) + fib(n-2);
}

V rekurzívnej funkcii riešime problém pomocou menších podproblémov toho istého typu
- Napríklad aby sme našli číslo x v utriedenom poli medzi indexami l a r, potrebujeme ho porovnať so stredným prvkom tohoto intervalu a potom riešiť tú istú úlohu pre menší interval
- Aj keď sme pôvodne chceli hľadať prvok v celom poli, úlohu rozšírime o parametre l a r, aby sa dala spraviť rekurzia

bool binSearch(int x, int l, int r, int A[]){
    if (l == r) return (A[l] == x);
    if (x <= A[(l+r)/2]) return binSearch(x, l, (l+r)/2, A);
    else return binSearch(x, (l+r)/2+1, r, A);
}

Druhý pohľad na rekurziu je dynamický: môžeme simulovať, čo sa v programe deje so zásobníkom
- Na zásobníku ukladáme parametre, lokálne premenné a miesto, kde v kóde sme skončili
- Skúsme napríklad odsimulovať, čo sa deje ak vo funkcii main zavoláme fib(3)
- Kvôli prehľadnosti si fib rozpíšeme na viac riadkov:

#include <iostream>
using namespace std;

int fib(int n) {
    if (n < 2) return 1;
    else {
        int a = fib(n - 1); // riadok (A)
        int b = fib(n - 2); // riadok (B)
        return a+b;
    }
}

int main(void) {
    int x = fib(3);    // riadok (C)
    cout << x << endl; 
}

Tu je priebeh programu (obsah zásobníka)

(1)          (2)                      (3)

                                       fib n=2
              fib n=3                  fib n=3, a=?, b=?, riadok A
main, x=?     main, x=?, riadok C      main, x=?, riadok C

(4)                             (5)
 
fib n=1                         
fib n=2, a=?, b=?, riadok A     fib n=2, a=1, b=?, riadok A
fib n=3, a=?, b=?, riadok A     fib n=3, a=?, b=?, riadok A
main, x=?, riadok C             main, x=?, riadok C             


(6)                             (7)
 
fib n=0                         
fib n=2, a=1, b=?, riadok B     fib n=2, a=1, b=1, riadok B
fib n=3, a=?, b=?, riadok A     fib n=3, a=?, b=?, riadok A
main, x=?, riadok C             main, x=?, riadok C             


(8)                             (9)

                                fib n=1
fib n=3, a=2, b=?, riadok A     fib n=3, a=2, b=?, riadok B 
main, x=?, riadok C             main, x=?, riadok C                 


(10)                            (11)

fib n=3, a=2, b=1, riadok B     
main, x=?, riadok C             main, x=3, riadok C

Efektívnejší výpočet Fibonacciho čísel

Priamočiary rekurzívny zápis výpočtu Fibonacciho čísel je neefektívny, lebo výpočet Fibonacciho čísel sa opakuje

Napr. pre n=4 počítame fib(2) dvakrát, pre n=6 päťkrát a pre n=20 až 4181-krát

Spomeňme si na zápis výpočtu bez rekurzie, s dvomi premennými:

F(n) spočíta v čase O(n)

int fibonacci(int n) {

    int f = 1;     // Cislo F(i) 
    int oldF = 0; // Cislo F(i-1)
    
    for (int i = 2; i <= n; i++) {
        int newF = f + oldF;  // spocitaj nove F(i) pre vyssie i
        oldF = f;             // poposuvaj hodnoty
        f = newF;
    }

    return f;
}

Prepíšeme ho na rekurziu:

int fib1(int a, int b, int i, int n) {
    /* a je F(i-1), b je F(i), spočítaj F(n), kde n>=i */
    if (n == i) return b;
    else return fib1(b, a+b, i+1, n);
}

int fib(int n){
    return fib1(1, 1, 1, n);
}

Namiesto dvoch premenných i a n si môžeme pamätať len ich rozdiel k=n-i

hodnota k nám vraví, koľkokrát máme ešte sčitovať dve posledné čísla

int fib1(int a, int b, int k) {
    /* a je F(i-1), b je F(i), spočítaj F(i+k) */
    if (k == 0) return b;
    else return fib1(b, a+b, k-1);
}

int fib(int n){
    fib1(1, 1, n-1);
}

Táto rekurzívna funkcia pracuje v čase O(n), rovnako ako verzia s cyklom.

Rozdeľuj a panuj, rýchle triedenia

Videli sme tri algoritmy na triedenie: bubblesort, insertsort, maxsort

Jednoduché, ale pomalé, kvadratická zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}

Dnes si ukážeme dve rýchlejšie triedenia, mergesort a quicksort.

obe používajú metódu rozdeľuj a panuj

Rozdeľuj a panuj je všeobecný rekurzívny postup, ktorým sa dá riešiť viacero problémov. Má nasledujúce fázy:

Rozdeľuj: rozdelíme problém na nejaké menšie časti (podproblémy), ktoré sa dajú riešiť ďalej samostatne.
Vyriešime podproblémy: rekurzívne vyriešime úlohu pre každý podproblém
Panuj: spojíme výsledky pre podproblémy do výsledku celkového problému.

Triedenie zlučovaním, MergeSort

V triedení zlučovaním sa pole veľkosti N rozdelí na polovicu najjednoduchším spôsobom - na prvú a druhú polovicu. Tieto rekurzívne utriedime, čím dostávame 2 utriedené postupnosti. Preto vo fáze panuj potrebujeme tieto dve polia zlúčiť (merge) do výsledného poľa.

void mergesort(int a[], int low, int high) {
/* utriedi prvky pola a od indexu low po index high (vratane) */

 
    // trivialny pripad: ak mame 1 alebo 0 prvkov
    if (low >= high) return;

    // rozdeluj: spocita stred triedeneho useku
    int mid = (low+high) / 2;

    //rekurzivne volanie na dva podproblemy
    mergesort(a, low, mid);       // triedi prvky od low po mid
    mergesort(a, mid+1, high);    // triedi prvky od mid+1 po high 

    // panuj: zluci dve utriedene postupnosti do jednej 
    merge(a, low, mid, high);
}

Zlučovanie utriedených postupností

Zaujímavým problémom je zlúčenie dvoch utriedených postupností. Predpokldajme teraz, že máme dve utriedené postupnosti A[0..N-1] a B[0..M-1] a chceme ich zlúčiť do utredeného poľa C dĺžky N+M.

Prvým prvkom výslednej postupnosti bude menší z prvkov A[0] a B[0]. Potom ostávajú postupnosti A[1..N-1] a B[0..M-1] alebo A[0..N-1] a B[1..M-1].
Vo všeobecnosti máme teraz postupnosti A[i..N-1] a B[j..M-1]. Ďalším prvkom postupnosti bude buď A[i] alebo B[j] a ostanú nám postupnosti A[i+1..N-1] a B[j..M-1] alebo A[i..N-1] a B[j+1..M-1].
Toto robíme dovtedy, kým s jedným poľom neskončíme. Vtedy na koniec dokopírujeme zvyšok druhého poľa.

Z toho dostávame nasledovnú funkciu.

void merge(int A[], int N, int B[], int M, int C[]) {
    /* zluci utriedene pole A dlzky N a utriedene pole B dlzky M 
     * do pola C, ktore musi mat dlzku aspon N+M */

    int i = 0;
    int j = 0;
    while (i < N && j < M) { // kym v oboch poliach zostavaju prvky
        if (A[i] <= B[j]) {
            C[i + j] = A[i]; // vysledok ukladame na (i+j)-te miesto
            i++;
        } else {
            C[i + j] = B[j];
            j++;
        }
    }

    while (i < N) { // ak skoncilo pole B, prekopirujeme zvysok pola A
        C[i + j] = A[i];
        i++;
    }

    while (j < M) {  // ak skoncilo pole A, prekopirujeme zvysok pola B
        C[i + j] = B[j];
        j++;
    }
}

Výsledný MergeSort

Ostáva už iba drobnosť: nezlučujeme dve nezávislé polia, ale prvky jedného poľa a navyše by sme radi, aby tie prvky v tomto poli aj skončili.

Funkcia namiesto dvoch vstupných polí dostane iba pole A a pozície začiatkov a koncov úsekov.
- Keďže zlučované úseky idú za sebou, stačia nám tri indexy: low, mid a high
- Hodnotu mid by sme si mohli aj dopočítať z low a high.
Druhý problém vyriešime pomocným poľom C, ktoré na konci nakopírujeme naspäť do A.
- Keďže merge už nevolá ďalšie funkcie, v zásobníku bude vždy len jedno pole C, po skončení zlučovania sa vždy vymaže.

#include <iostream>
using namespace std;

const int MAX = 100;

void merge(int A[], int low, int mid, int high) {
    /* V poli A su utriedene useky A[low..mid] a A[mid+1..high.
     * Zluci ich do utriedeneho useku A[low..high]. */

    int C[MAX];       // pomocne pole
    int i = low;      // poloha v prvej catsi pola
    int j = mid + 1;  // poloha v druhej casti pola
    int k = 0;        // poloha v zlucenom poli
    while (i <= mid && j <= high) { // kym v oboch poliach zostavaju prvky
        if (A[i] <= A[j]) {  // pouzi prvok z lavej casti
            C[k] = A[i];
            i++;
            k++;
        } else {            // pouzi prvok z pravej casti
            C[k] = A[j];
            j++;
            k++;
        }
    }

    while (i <= mid) { // ak skoncila prava cast, prekopirujeme zvysok lavej
        C[k] = A[i];
        i++;
        k++;
    }

    while (j <= high) { // ak skoncila lava cast, prekoprujeme zvysok pravej
        C[k] = A[j];
        j++;
        k++;
    }

    for (int k = low; k <= high; k++) {
        A[k] = C[k - low];
    }
}

void mergesort(int A[], int low, int high) {
    /* utriedi prvky pola a od indexu low po index high (vratane) */

    // trivialny pripad: ak mame 1 alebo 0 prvkov
    if (low >= high) return;

    // rozdeluj: spocita stred triedeneho useku
    int mid = (low + high) / 2;

    //rekurzivne volanie na dva podproblemy
    mergesort(A, low, mid);
    mergesort(A, mid + 1, high);

    // panuj: zluci dve utriedene postupnosti do jednej
    merge(A, low, mid, high);
}

int main(void) {
    const int N = 10;
    int A[N] = {13, 1, 5, 7, 2, 4, 8, 10, 3, 24};
    mergesort(A, 0, N - 1);
    for (int i = 0; i < N; i++) cout << A[i] << " ";
}

Ukážka na príklade

Pole A[]= {6, 1, 5, 7, 2, 4, 8, 9, 3, 0};

Všetky volania:

sort(0,9) sort(0,4) sort(0,2) sort(0,1) sort(0,0) 
          .         .         .         sort(1,1)
          .         .         .         merge(0,0,1)
          .         .         sort(2,2)
          .         .         merge(0,1,2)
          .         sort(3,4) sort(3,3)
          .         .         sort(4,4)
          .         .         merge(3,3,4)
          .         merge(0,2,4)
          sort(5,9) sort(5,7) sort(5,6) sort(5,5)
          .         .         .         sort(6,6)
          .         .         .         merge(5,5,6)
          .         .         sort(7,7)
          .         .         merge(5,6,7)
          .         sort(8,9) sort(8,8)
          .         .         sort(9,9)
          .         .         merge(8,8,9)
          .         merge(5,7,9)
          merge(0,4,9)

Čo sa deje v poli:

merge(A,0,0,1): |6|1|5 7 2 4 8 9 3 0 -> |1 6|5 7 2 4 8 9 3 0
merge(A,0,1,2): |1 6|5|7 2 4 8 9 3 0 -> |1 5 6|7 2 4 8 9 3 0
merge(A,3,3,4):  1 5 6|7|2|4 8 9 3 0 ->  1 5 6|2 7|4 8 9 3 0
merge(A,0,2,4): |1 5 6|2 7|4 8 9 3 0 -> |1 2 5 6 7|4 8 9 3 0
merge(A,5,5,6):  1 2 5 6 7|4|8|9 3 0 ->  1 2 5 6 7|4 8|9 3 0
merge(A,5,6,7):  1 2 5 6 7|4 8|9|3 0 ->  1 2 5 6 7|4 8 9|3 0
merge(A,8,8,9):  1 2 5 6 7 4 8 9|3|0|->  1 2 5 6 7 4 8 9|0 3|
merge(A,5,7,9):  1 2 5 6 7|4 8 9|0 3|->  1 2 5 6 7|0 3 4 8 9|
merge(A,0,4,9): |1 2 5 6 7|0 3 4 8 9|-> |0 1 2 3 4 5 6 7 8 9|

Odhad zložitosti

Zlučovanie dvoch postupností ktoré spolu obsahujú N prvkov trvá čas O(N). Prečo?

V algoritme máme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle log_2 N} úrovní rekurzie, lebo na prvej spracovávame úseky dĺžky N, na druhej N/2 na tretej N/4 atď, až pol Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle log_2 N} úrovniach dostaneme úseky dĺžky 1. Na každej úrovni je každý prvok najviac v jednom zlučovaní, teda celkový čas zlučovaní na každej úrovni je O(N). Celkový čas výpočtu je O(N log N).

Quicksort

Quicksort je tiež založený na metóde rozdeľuj a panuj. Postupuje nasledovne:

Rozdeľuj: prvky poľa rozdelí na dve skupiny: prvky menšie ako nejaké x a prvky väčšie alebo rovné x
- hodnotu x nazývame pivot
Rekurzívne utriedi obe skupiny prvkov a dostáva dve utriedené postupnosti - utriedenú postupnosť menších prvkov a utriedenú postupnosť väčších prvkov.
Panuj: stačí dať tieto utriedené postupnosti za seba (najskôr menšie, potom väčšie)

void quicksort(int A[], int low, int high) {
    /* utriedi prvky v A medzi low a high (vratane) */
    
    if (low >= high) return;  // trivialny pripad: 0 alebo 1 prvok

    // rozdelenie: mid je posledny index medzi mensimi prvkami
    int mid = partition(A, low, high);

    quicksort(A, low, mid);     // rekurzivne utried mensie prvky
    quicksort(A, mid + 1, high); // rekurzivne utried vacsie prvky

    //zlucenie nebude treba - su spravne za sebou
}

Čo sa stane, ak funkcia partition zvolí taký pivot, že jedna zo skupín je prázdna?

Aby sme sa takýmto problémom vyhli, upresníme trochu úlohu funkcie partition:

ako pivot x si zvolí jeden z prvkov A[low..high]
preusporiada túto časť poľa tak, že
- A[low..mid-1] obsahuje prvky < x
- A[mid+1..high] onsahuje prvky >= x
- A[mid] obsahuje x, ktorý je teda už na svojom finálnom mieste
vráti index mid

Potom stačí rekurziu volať na A[low..mid-1] a A[mid+1..high]

Ak sme teda začali s N prvkami, ľavá aj pravá časť poľa bude mať najviac N-1 prvkov.

Rozdelenie prvkov, funkcia partition

Jednoduchá implementácia funkcie partition by mohla používať dve pomocné polia: do jedného si dá menšie prvky, do druhého väčšie.

Dá sa však ľahko napísať priamo v poli A, bez pomocných polí. Počas algoritmu budeme udržiavať nasledujúci invariant:

na indexe low je pivot x
na indexoch low+1..lastLeft sú prvky menšie ako x
na indexoch lastLeft+1..unknown-1 sú prvky >= x
na indexoch unknown..high sú prvky, ktoré sme ešte s x neporovnali

V každom kroku porovnáme A[unknown] s x

ak je menší, potrebujeme ho dať do ľavej časti, vymeníme ho teda s A[lastLeft+1] a rozšírime ľavú časť
ak je >= x, jednoducho rozšírime pravú časť

Nakoniec ešte vymeníme A[low] a A[lastLeft], čím sa pivot dostane na svoje miesto

int partition(int A[], int low, int high) {
    /* vrati index mid (low<=mid<=high)
     * a preusporiada prvky v a[low..high] tak, ze plati
     * A[low..mid-1] obsahuje prvky < A[mid]
     * A[mid+1..high] obsahuje prvky >= A[mid] */

    // ak chceme pouzit iny prvok ako pivot, vymenime ho s a[low]
    int pivot = A[low];
    int lastLeft = low;
    for (int unknown = low + 1; unknown <= high; unknown++) {
        if (A[unknown] < pivot) {
            lastLeft++;
            swap(A[unknown], A[lastLeft]);
        }
    }
    swap(A[low], A[lastLeft]);
    return lastLeft;
}

Výsledný Quicksort

#include <iostream>
using namespace std;

void swap(int &x, int &y) {
    /* Vymeň hodnoty premenných x a y. */
    int tmp = x;
    x = y;
    y = tmp;
}

int partition(int A[], int low, int high) {
    /* vrati index mid (low<=mid<=high)
     * a preusporiada prvky v a[low..high] tak, ze plati
     * A[low..mid-1] obsahuje prvky < A[mid]
     * A[mid+1..high] obsahuje prvky >= A[mid] */

    // ak chceme pouzit iny prvok ako pivot, vymenime ho s a[low]
    int pivot = A[low];
    int lastLeft = low;
    for (int unknown = low + 1; unknown <= high; unknown++) {
        if (A[unknown] < pivot) {
            lastLeft++;
            swap(A[unknown], A[lastLeft]);
        }
    }
    swap(A[low], A[lastLeft]);
    return lastLeft;
}

void quicksort(int A[], int low, int high) {
    /* utriedi prvky v A medzi low a high (vratane) */
    
    if (low >= high) return;  // trivialny pripad: 0 alebo 1 prvok

    // rozdelenie: mid je posledny index medzi mensimi prvkami
    int mid = partition(A, low, high);

    quicksort(A, low, mid - 1);     // rekurzivne utried mensie prvky
    quicksort(A, mid + 1, high); // rekurzivne utried vacsie prvky
}

int main(void) {
    const int N = 10;

    int A[N] = {6, 1, 5, 7, 2, 4, 8, 9, 3, 0};
    quicksort(A, 0, N - 1);
    for (int i = 0; i < N; i++) cout << A[i] << " ";
}

Príklad

Volania funkcií

sort(0,9) sort(0,5) sort(0,-1)
          .         sort(1,5) sort(1,0)
          .         .         sort(2,5) sort(2,4) sort(2,2)
          .         .         .         .         sort(4,4)
          .         .         .         sort(6,5)
          sort(7,9) sort(7,8) sort(7,7)
                    .         sort(9,8)
                    sort(10,9)

Čo robí partition:

partition(0,9): |6 1 5 7 2 4 8 9 3 0| -> |0 1 5 2 4 3|6|9 7 8|
partition(0,5): |0 1 5 2 4 3|6 9 7 8  -> |0|1 5 2 4 3|6 9 7 8
partition(1,5):  0|1 5 2 4 3|6 9 7 8  ->  0|1|5 2 4 3|6 9 7 8
partition(2,5):  0 1|5 2 4 3|6 9 7 8  ->  0 1|3 2 4|5|6 9 7 8
partition(2,4):  0 1|3 2 4|5 6 9 7 8  ->  0 1|2|3|4|5 6 9 7 8
partition(7,9):  0 1 2 3 4 5 6|9 7 8| ->  0 1 2 3 4 5 6|8 7|9|
partition(7,8):  0 1 2 3 4 5 6|8 7|9  ->  0 1 2 3 4 5 6|7|8|9

Cvičenie:

Ako sa bude Quicksort správať, keď mu dáme utriedené pole?
Ako sa bude správať, ak budú prvky v poli od najväčšieho po najmenšie?

Odhad zložitosti

V ideálnom prípade pivot rozdelí pole na dve rovnako veľké časti. Vtedy je čas výpočtu O(N log N), podobne ako pre Mergesort.

Nepríjemné je, keď pivot je vždy najmenší alebo najväčší prvk v danom úseku. Vtedy je čas Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(N^2)} . Dobrá správa je, že takýchto prípadov nie je príliš veľa.

Aby sme sa vyhli problémom, ak je vstupné pole (takmer) utriedené, môžeme ho pred triedením náhodne premiešať alebo vyberať ako pivot náhodný prvok z intervalu

Iná implementácia

Občas sa môžete stretnúť aj s takto napísaným quicksortom. Skúste si premyslieť, prečo funguje a prečo si môžeme dovoliť niektoré prvky vynechať.

void quickSort(int A[], int left, int right) {
    if (left>=right) return;
    int i = left, j = right;
    int pivot = A[(left + right) / 2];

    /* partition */
    while (i <= j) {
        while (A[i] < pivot) i++;
        while (A[j] > pivot) j--;
        if (i <= j) {
            int tmp = A[i]; A[i] = A[j]; A[j] = tmp;
            i++; j--;
        }
    };

    /* rekurzia */
    quickSort(A, left, j);
    quickSort(A, i, right);
}

Zhrnutie: triedenia

Jednoduché triedenia: bubblesort, insertsort, maxsort

Jednoduché, ale pomalé, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)}

Rekurzívne triedenia, rozdeľuj a panuj

Rýchlejšie, zložitejšie
Mergesort, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)}
Quicksort, zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} v najhoršom prípade, pre väčšinu stupov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)} , väčšinou rýchlejší ako Mergesort

Príklad: na mojom počítači som triedila pol milióna náhodne permutovaných čísel programami z prednášok

quicksort: 0.25s
mergesort: 0.27s
insertionsort: 58s

Medián

Medián prvkov v poli je prvok, ktorý by po utriedení bol v strede poľa.

Pre N prvkové pole je teda (N/2)-ty najmenší prvok.

Jednoduchý algoritmus: utriedime pole, vypíšeme A[N/2].

Zložitosť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} alebo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n\log n)} podľa použitého triedenia

Ukážeme si rýchlejší algoritmus, Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n^2)} v najhoršom prípade, väčšina vstupov Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle O(n)}

Zovšeobecníme problém: hľadáme prvok, ktorý by bol v utriedenom pole na mieste k (0<=k<n)
Podobný na Quicksort, ale niektoré časti nebudeme triediť

Postup:

Pole si rozdelíme ako pri quicksorte. Nech prvá časť má m prvkov. Potom
- ak k<m, stačí nám hľadať k-ty najmenší prvok v prvej časti
- ak k>m, potrebujeme nájsť (k-m)-tý prvok v druhej časti

int select(int A[], int low, int high, int k) {
    /* vrati prvok, ktory by bol na pozicii low+k, keby sme A[low..high] utriedili */
    assert(0 <= k && k <= high - low);
    if (low == high) return A[low];

    int mid = partition(A, low, high);
    if (k < mid - low) select(A, low, mid - 1, k);
    else if (k > mid - low) select(A, mid + 1, high, k - mid + low - 1);
    else return A[mid];
}

Prednáška 11

Organizačné poznámky

Tento týždeň štvrtok rektorské voľno, piatok sviatok. Pondelkové a utorkové cvičenia normálne.
Ak máte záujem o nepovinné cvičenia, aj keď je rektorské voľno, prihláste sa emailom B.Brejovej najneskôr v stredu poobede.
Záverečný test bude v piatok 13.12. o 14:00 v posluchárni B (pozor, zmena času).
DÚ5 odovzdávajte do pondelka 4.11. 22:00, PDÚ2 odovzdávajte do piatka 8.11. 22:00.

Vypisovanie variácií s opakovaním

Vypíšte všetky trojice cifier, pričom každá cifra je z množiny {0..n-1} a cifry sa môžu opakovať (variácie 3-tej triedy z n prvkov). Napr. pre n=2:

Veľmi jednoduchý program s troma cyklami:

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cin >> n;
    for(int i=0; i<n; i++) {
        for(int j=0; j<n; j++) {
            for(int k=0; k<n; k++) {
                cout << i << j << k << endl;
            }
        }
    }
}

Rekurzívne riešenie pre všeobecné k

Čo ak chceme k-tice pre všeobecné k? Využijeme rekurziu.

Variácie k-tej triedy vieme rozdeliť na n skupín podľa prvého prvku:
- tie čo začínajú na 0, tie čo začínajú na 1, ..., tie čo začínajú na n-1.
V každej skupine ak odoberieme prvý prvok, dostaneme variácie triedy k-1

#include <iostream>
using namespace std;

void vypis(int a[], int k) {
    for (int i = 0; i < k; i++) {
        cout << a[i];
    }
    cout << endl;
}

void generuj(int a[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        vypis(a, k);
    } else {
        for (int x = 0; x < n; x++) {
            a[i] = x;
            generuj(a, i + 1, k, n);
        }
    }
}

int main(void) {
    const int maxK = 100;
    int a[maxK];
    int k, n;
    cin >> k >> n;
    cout << "Zadajte k a n: ";
    generuj(a, 0, k, n);
}

Ďalšie rozšírenia

Čo ak chceme všetky k-tice písmen A-Z?
Čo ak chceme všetky DNA reťazce dĺžky k (DNA pozostáva z "písmen" A,C,G,T)?

// pouzi n=26
void vypis(int a[], int k) {
    for (int i = 0; i < k; i++) {
        char c = 'A'+a[i];
        cout << c;
    }
    cout << endl;
}

// pouzi n=4
void vypis(int a[], int k) {
    char abeceda[5] = "ACGT";
    for (int i = 0; i < k; i++) {
        cout << abeceda[a[i]];
    }
    cout << endl;
}

Cvičenia

Ako by sme vypisovali všetky k-ciferné hexadecimálne čísla (šestnástková sústava), kde používame cifry 0-9 a písmená A-F?
Ako by sme vypisovali všetky k-tice písmen v opačnom poradí, od ZZZ po AAA?

Variácie bez opakovania

Teraz chceme vypísať všetky k-tice cifier z množiny {0,..,n-1}, v ktorých sa žiaden prvok neopakuje (pre k=n dostávame permutácie)

Príklad pre k=3, n=3

Skúšanie všetkých možností

Jednoduchá možnosť: použijeme predchádzajúci program a pred výpisom skontrolujeme, či je riešenie správne

Prvý pokus:

bool spravne(int a[], int k, int n) {
    /* je v poli a dlzky k kazde cislo od 0 po n-1 najviac raz? */
    bool bolo[maxN];
    for (int i = 0; i < n; i++) {
        bolo[i] = false;
    }
    for (int i = 0; i < k; i++) {
        if (bolo[a[i]]) return false;
        bolo[a[i]] = true;
    }
    return true;
}

void generuj(int a[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        if (spravne(a, k, n)) {
            vypis(a, k);
        }
    } else {
        for (int x = 0; x < n; x++) {
            a[i] = x;
            generuj(a, i + 1, k, n);
        }
    }
}

Cvičenie: ako by sme napísali kontrolu, ak by sme nepoznali n?

Prehľadávanie s návratom, backtracking

Predchádzajúce riešenie je neefektívne, lebo prechádza cez všetky variácie s opakovaním a veľa z nich zahodí.
- Napríklad pre k=7 a n=10 pozeráme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 10^7} variácií s opakovaním, ale iba 604800 z nich je správnych, čo je asi 6%
Len čo sa v poli a vyskytne opakujúca sa cifra, chceme túto vetvu prehľadávania ukončiť, lebo doplnením ďalších cifier problém neodstránime
Spravíme funkciu moze(a,i,x), ktorá určí, či je možné na miesto i v poli a dať cifru x
Testovanie správnosti vo funkcii generuj sa dá vynechať

bool moze(int a[], int i, int x) {
    /* Mozeme dat hodnotu x na poziciu i v poli a?
     * Mozeme, ak sa nevyskytuje v a[0..i-1] */
    for (int j = 0; j < i; j++) {
        if (a[j] == x) return false;
    }
    return true;
}

void generuj(int a[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        vypis(a, k);
    } else {
        for (int x = 0; x < n; x++) {
            if (moze(a, i, x)) {
                a[i] = x;
                generuj(a, i + 1, k, n);
            }
        }
    }
}

Možné zrýchlenie: vytvoríme si trvalé pole bolo, v ktorom bude zaznamené, ktoré cifry sa už vyskytli a to použijeme vo funkcii moze.

Po návrate z rekurzie nesmieme zabudúť príslušnú hodnotu odznačiť!

void generuj(int a[], bool bolo[], int i, int k, int n) {
    /* v poli a dlzky k mame prvych i cifier,
     * v poli bolo mame zaznamenane, ktore cifry su uz pouzite,
     * chceme vygenerovat vsetky moznosti
     * poslednych k-i cifier */
    if (i == k) {
        vypis(a, k);
    } else {
        for (int x = 0; x < n; x++) {
            if (!bolo[x]) {
                a[i] = x;
                bolo[x] = true;
                generuj(a, bolo, i + 1, k, n);
                bolo[x] = false;
            }
        }
    }
}

int main(void) {
    const int maxK = 100;
    const int maxN = 100;
    int a[maxK];
    bool bolo[maxN];
    int k, n;
    cout << "Zadajte k a n (k<=n): ";
    cin >> k >> n;
    for (int i = 0; i < n; i++) {
        bolo[i] = false;
    }
    generuj(a, bolo, 0, k, n);
}

Cvičenia: ako potrebujeme zmeniť program, aby sme generovali všetky postupnosti k cifier z množiny {0,..,n-1}, také, že:

z každej cifry sú v postupnosti najviac 2 výskyty?
žiadne dve po sebe idúce cifry nie sú rovnaké?
súčet cifier je aspoň S?

Technika rekurzívneho prehľadávania všetkých možností s orezávaním beznádejných vetiev sa nazýva prehľadávanie s návratom alebo backtracking.

Hľadáme všetky postupnosti, ktoré spĺňajú nejaké podmienky
- Vo všeobecnosti nemusia byť rovnako dlhé
Ak máme celú postupnosť, vieme otestovať, či spĺňa podmienku (funkcia spravne)
Ak máme časť postupnosti a nový prvok, vieme otestovať, či po pridaní tohto prvku má ešte šancu tvoriť časť riešenia (funkcia moze)
- Funkcia moze nesmie vrátiť false, ak ešte je možné riešenie
- Môže vrátiť true, ak už nie je možné riešenie, ale nevie to ešte odhaliť
- Snažíme sa však odhaliť problém čím skôr

Všeobecná schéma

void generuj(int a[], int i) {
    /* v poli a dlzky k mame prvych i cisel z riesenia */
    if (spravne(a, i)) { /* ak uz mame cele riesenie, vypisme ho */
        vypis(a, i);
    } else {
        pre vsetky hodnoty x {
            if (moze(a,i,x) {
                a[i] = x;
                generuj(a, i + 1);
            }
        }
    }
}

Prehľadávanie s návratom môže byť vo všeobecnosti veľmi pomalé, čas výpočtu exponenciálne rastie.

Problém 8 dám

Cieľom je rozmiestniť n dám na šachovnici nxn tak, aby sa žiadne dve navzájom neohrozovali, tj. aby žiadne dve neboli v rovnakom riadku, stĺpci, ani na rovnakej uhlopriečke.

Príklad pre n=4:

 . * . .
 . . . *
 * . . .
 . . * .

V každom riadku bude práve jedna dáma, teda môžeme si riešenie reprezetovať ako pole damy dĺžky n, kde damy[i] je stĺpec, v ktorom je dáma na riadku i
Podobne ako v predchádzajúcom príklade chceme do poľa dať čísla od 1 po n, aby spĺňali ďalšie podmienky (v každom stĺpci a na každej uhlopriečke najviac 1 dáma)
Vytvoríme si polia, kde si budeme pamätať pre každý stĺpec a uhlopriečku, či už je obsadený
Uhlopriečky v oboch smeroch očísľujeme číslami od 0 po 2n-2
- V jednom smere majú miesta na uhlopriečke rovnaký súčet, ten teda bude číslom uhlopriečky
- V druhom smere majú rovnaký rozdiel, ten však môže byť aj záporný, pričítame n-1
Pre jednoduchosť použijeme globálne premenné, lebo potrebujeme veľa polí
- Globálne premenné spôsobujú problémy vo väčších programoch: mená premenných sa môžu "biť", môžeme si omylom prepísať číslo dôležité v inej časti programu
- Mohli by sme si tiež spraviť struct obsahujúci všetky premenné potrebné premenné v rekurzii a odovzdávať si ten

#include <iostream>
using namespace std;

/* globalne premenne */
const int maxN = 100;
int n;
int damy[maxN];       /* pole ktore obsahuje stlpec s damou v riadku i*/
bool bolStlpec[maxN]; /* pole ktore obsahuje true ak stlpec obsadeny damou */
bool bolaUhl1[2 * maxN - 1];  /* polia ktore obsahuju true ak uhlopriecky obsadene */
bool bolaUhl2[2 * maxN - 1];
int pocet;       /* pocet najdenych rieseni */

int uhl1(int i, int j) {
    /* na ktorej uhlopriecke je riadok i, stlpec j v smere 1? */
    return i + j;
}

int uhl2(int i, int j) {
    /* na ktorej uhlopriecke je riadok i, stlpec j v smere 2? */
    return n - 1 + i - j;
}

void vypis() {
    /* vypis sachovnicu textovo a zvys pocitadlo rieseni */
    pocet++;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (damy[i] == j) cout << " *";
            else cout << " .";
        }
        cout << endl;
    }
    cout << endl;
}

void generuj(int i) {
    /* v poli damy mame prvych i dam, dopln dalsie */
    if (i == n) {
        vypis();
    } else {
        for (int j = 0; j < n; j++) {
            /* skus dat damu na riadok i, stlpec j */
            if (!bolStlpec[j]
                    && !bolaUhl1[uhl1(i, j)] && !bolaUhl2[uhl2(i, j)]) {
                damy[i] = j;
                bolStlpec[j] = true;
                bolaUhl1[uhl1(i, j)] = true;
                bolaUhl2[uhl2(i, j)] = true;
                generuj(i + 1);
                bolStlpec[j] = false;
                bolaUhl1[uhl1(i, j)] = false;
                bolaUhl2[uhl2(i, j)] = false;
            }
        }
    }
}

int main(void) {
    cout << "Zadajte velkost sachovnice: ";
    cin >> n;
    for (int i = 0; i < n; i++) {
        bolStlpec[i] = false;
    }
    for (int i = 0; i < 2 * n + 1; i++) {
        bolaUhl1[i] = false;
        bolaUhl2[i] = false;
    }

    /* rekuzia */
    pocet=0;
    generuj(0);
    cout << "Pocet rieseni: " << pocet << endl;
}

Generovanie všetkých podmnožín

Chceme vypísať všetky podmnožiny množiny {0,..,m-1}. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. {0,1} = {1,0}), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre m=2 máme podmnožiny

{}
{0}
{0,1}
{1}

Podmnožinu vieme vyjadriť ako binárne pole dĺžky m, kde a[i]=0 znamená, že i nepatrí do množiny a a[i]=1 znamená, že patrí. Teda môžeme použiť predchádzajúci program pre n=2,k=m a zmeniť iba výpis:

void vypis(int a[], int m) {
    cout << "{";
    char oddelovac[2] = "";
    for (int i = 0; i < m; i++) {
        if (a[i] == 1) {
            cout << oddelovac;
            strcpy(oddelovac, ",");
            cout << i;
        }
    }
    cout << "}" << endl;
}

V premennej oddeľovač si pamätáme, akým reťazcom máme oddeliť ďalšie vypisované číslo od predchádzajúceho.
- Ak ešte žiadne nebolo, oddeľovač je prázdny reťazec.
- Ak už sme niečo vypísali, oddeľovač je čiarka.

Namiesto poľa intov môžeme použiť pole boolovských hodnôt a celý program trochu prispôsobiť tomu, že generujeme podmnožiny:

#include <iostream>
#include <cstring>
using namespace std;

void vypis(bool a[], int m) {
    cout << "{";
    char oddelovac[2] = "";
    for (int i = 0; i < m; i++) {
        if (a[i]) {
            cout << oddelovac;
            strcpy(oddelovac, ",");
            cout << i;
        }
    }
    cout << "}" << endl;
}

void generuj(bool a[], int i, int m) {
    /* v poli a dlzky k mame rozhodnutie o prvych i
     * prvkoch, chceme vygenerovat vsetky podmnoziny
     * prvkov {i..m-1} */
    if (i == m) {
        vypis(a, m);
    } else {
        a[i] = true;
        generuj(a, i + 1, m);
        a[i] = false;
        generuj(a, i + 1, m);
    }
}

int main(void) {
    const int maxM = 100;
    int m;
    cin >> m;
    bool a[maxM];
    generuj(a, 0, m);
}

Pre n=3 program vypíše:

{0,1,2}
{0,1}
{0,2}
{0}
{1,2}
{1}
{2}
{}

Cvičenie: Čo by vypísal, ak by sme prehodili true a false v rekurzii?

Problém batoha, Knapsack problem

Zlodej sa vlúpal do obchodu a vidí n vecí, pričom pre každú z nich vie odhadnúť jej hmostnosť a cenu, za ktorú by ju vedel predať. V svojom batohu však vie odniesť len veci s celkovou hmotnosťou najviac W kilogramov. Ako má vybrať veci, aby mali čo najväčšiu cenu a aby ich celková hmostnosť neprekročila W?

Príklad: majme n=3 veci, pričom vec 0 má hmostnoť 10 a cenu 6, vec 1 má hmotnosť 8 a cenu 4 a vec 2 má hmotnosť 6 a cenu 3. Zlodej unesie najviac 15. Na vstupe to zapíšeme takto:

Zadaj pocet predmetov: 3
Zadaj hmotnost a cenu 0-teho predmetu: 10 6
Zadaj hmotnost a cenu 1-teho predmetu: 8 4
Zadaj hmotnost a cenu 2-teho predmetu: 6 3
Zadaj nosnost batoha: 15
Zober predmety 1, 2. Ich cena je 7.

Najlepšie je zobrať veci 1 a 2. Ich cena je 7 a súčet hmotností 14.

Tento problém ešte stretnete v ďalších ročníkoch štúdia, teraz si ukážeme jednoduchý program, ktorý prehľadáva všetky možnosti.

Jednoduché riešenie: pozeráme všetky podmnožiny

Ako predtým, generujeme všetky podmnožiny a pre každú spočítame, či jej hmotnosť nepresahuje nosnosť batoha. Podmnožiny však nevypisujeme, ale porovnávame s najlepšou nájdenou doteraz.

#include <iostream>
#include <cstring>
using namespace std;

/* struktura na ukladanie udajov o jednej veci */
struct vec {
    int hmotnost;
    int cena;
};

const int maxN = 100; /* maximalny pocet veci */

/* globalne premenne pouzivane v rekurzii */
int n;           /* celkovy pocet veci v obchode */
vec a[maxN];     /* pole veci */
int maxCena;     /* najlepsie doteraz najdene riesenie */
bool maxZober[maxN];  /* ktore veci su v najlepsom rieseni */
int nosnost;     /* kolko unesie batoh */

/* spocitaj sucet hmotnosti vybranych predmetov */
int sucetHmotnosti(bool zober[]) {
    int sucet = 0;
    for (int i = 0; i < n; i++) {
        if(zober[i]) sucet += a[i].hmotnost;
    }
    return sucet;
}

/* spocitaj sucet cien vybranych predmetov */
int sucetCien(bool zober[]) {
    int sucet = 0;
    for (int i = 0; i < n; i++) {
        if(zober[i]) sucet += a[i].cena;
    }
    return sucet;
}

/* vypis zoznam vybranych predmetov */
void vypis(bool zober[]) {
    cout << "Zober predmety ";
    char oddelovac[2] = "";    
    for (int i = 0; i < n; i++) {
        if (zober[i]) {
            cout << oddelovac;
            strcpy(oddelovac, ",");
            cout << i;
        }
    }
    cout << ". Ich cena je " << sucetCien(zober) << "." << endl;
}

void generuj(bool zober[], int i) {
    /* v poli a dlzky k mame rozhodnutie o prvych i
     * prvkoch, chceme vygenerovat vsetky podmnoziny
     * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */
    if (i == n) {
        /* uz sme sa rozhodli o kazdom prvku. Zistime, ci mame hmostnost
         * vybranych predmetov <= nosnost */
        if(sucetHmotnosti(zober)<=nosnost) {
            /* ak ano, zistime, ci cena vybranych predmetov
             * je viac ako doteraz najlepsie maximum */
            int cena = sucetCien(zober);
            if(cena>maxCena) {
                /* prekopiruj sucasny vyber do najlepsieho */
                maxCena = cena;
                for(int i=0; i<n; i++) {
                    maxZober[i] = zober[i];
                }
            }
        }
    } else {
        /* dosad true aj false na miesto i
         * a skusaj vsetky moznosti pre zvysok pola */
        zober[i] = true;
        generuj(zober, i+1);
        zober[i] = false;
        generuj(zober, i+1);
    }
}

int main(void) {
    cout << "Zadaj pocet predmetov: ";
    cin >> n;
    /* nacitame hmotnost a cenu predmetov */
    for(int i=0; i<n; i++) {
        cout << "Zadaj hmotnost a cenu " << i << "-teho predmetu: ";
        cin >> a[i].hmotnost >> a[i].cena;
    }
    /* nacitame nostnost */
    cout << "Zadaj nosnost batoha: ";
    cin >> nosnost;
    
    bool zober[maxN];
    maxCena = -1; /* doteraz najlepsie riesenie ma cenu -1 */
    generuj(zober, 0); /* prehladavaj vsetky moznosti */

    vypis(maxZober); /* vypis najlepsie najdene riesenie */
}

Trochu rýchlejší program: skončíme vždy keď prekročíme nosnosť

Keď už sme sa rozhodli o prvých i veciach, sčítame hmotnosť tých, čo sme vybrali, a ak prekračuje nosnosť, túto vetvu hľadania ukončíme - nemá zmysel dopĺňať ďalšie hodnoty do zvyšku poľa, ak už zvolené veci sú príliš ťažké.

/* spocitaj sucet hmotnosti vybranych predmetov,
 * ale uvazujme iba prvych k predmetov  */
int sucetHmotnosti(bool zober[], int k) {
    int sucet = 0;
    for (int i = 0; i < k; i++) {
        if(zober[i]) sucet += a[i].hmotnost;
    }
    return sucet;
}

void generuj(bool zober[], int i) {
    /* v poli a dlzky k mame rozhodnutie o prvych i
     * prvkoch, chceme vygenerovat vsetky podmnoziny
     * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */

    /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */
    if(sucetHmotnosti(zober, i) > nosnost) return;
    if (i == n) {
        /* uz sme sa rozhodli o kazdom prvku.
         * Sucasne vieme, ze hmostnost
         * vybranych predmetov <= nosnost.
         * Zistime teda, ci cena vybranych predmetov
         * je viac ako doteraz najlepsie maximum */
        int cena = sucetCien(zober);
        if (cena > maxCena) {
            /* prekopiruj sucasny vyber do najlepsieho */
            maxCena = cena;
            for (int i = 0; i < n; i++) {
                maxZober[i] = zober[i];
            }
        }
    } else {
        /* dosad true aj false na miesto i
         * a skusaj vsetky moznosti pre zvysok pola */
        zober[i] = true;
        generuj(zober, i + 1);
        zober[i] = false;
        generuj(zober, i + 1);
    }
}

Ešte rýchlejší program: neprepočítavame nosnosť a cenu vždy znovu a znovu

Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho si môžeme v rekurzii udržiavať aktuálnu hmotnosť aj cenu doteraz vybraných predmetov.

void generuj(bool zober[], int i, int hmotnost, int cena) {
    /* v poli a dlzky k mame rozhodnutie o prvych i
     * prvkoch, hmotnost je sucet hmotnosti uz vybranych predmetov
     * a cena je sucet ich cien.
     * Chceme vygenerovat vsetky podmnoziny
     * prvkov {i..n-1} a kazdu skontrolovat a porovnat s maximom */

    /* ak uz sme prekrocili nosnost, nemusime pokracovat v hladani */
    if(hmotnost > nosnost) return;
    if (i == n) {
        /* uz sme sa rozhodli o kazdom prvku.
         * Sucasne vieme, ze hmostnost
         * vybranych predmetov <= nosnost.
         * Zistime teda, ci cena vybranych predmetov
         * je viac ako doteraz najlepsie maximum */
        if (cena > maxCena) {
            /* prekopiruj sucasny vyber do najlepsieho */
            maxCena = cena;
            for (int i = 0; i < n; i++) {
                maxZober[i] = zober[i];
            }
        }
    } else {
        /* dosad true aj false na miesto i
         * a skusaj vsetky moznosti pre zvysok pola */
        zober[i] = true;
        generuj(zober, i + 1, hmotnost + a[i].hmotnost, cena + a[i].cena);
        zober[i] = false;
        generuj(zober, i + 1, hmotnost, cena);
    }
}

V main zavoláme generuj(zober, 0, 0, 0);
- Prečo sme nastavili cenu aj hmotnost na 0?

Cvičenia 6

Rekurzívne umocňovanie

Napíšte rekurzívnu funkciu int power(int x, int k), ktorá spočíta mocninu Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^k} pre Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle k\ge 0} .

Jednoduchšia možnosť sa podobá na rekurzívny výpočet faktoriálu z prednášky 9 a je založená na vzťahoch:

koľko má byť Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^0} ?
ako dostaneme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^k} , keď poznáme Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^{k-1}} ?

Rýchlejšie ale bude fungovať algoritmus, ktorý pre k>0 spočíta do pomocnej premennej rekurzívne Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^{k/2}} (pričom uvažujeme celočíselné delenie) a potom získa výsledok najviac dvoma ďalšími násobeniami, podľa parity čísla k.

Výpis čísla

Napíšte rekurzívnu funkciu void printBinary(int x), ktorá vypíše zápis čísla x v dvojkovej sústave, pričom nepoužije pomocné pole, ani žiadne hotové knižničné funkcie na výpis binárnych čísel. Napríklad printBinary(11) má byť 1011, lebo 11 = 8 + 2 + 1.

Môžete postupovať podobne, ako keď sme do reťazca ukladali zápis čísla v desiatkovej sústave: x%2 je posledná cifra čísla a x/2 potom predstavuje zvyšné cifry čísla. Tie však potrebujeme vypísať skôr ako poslednú cifru a na to použijeme rekurziu.

Čo vypíše program?

Bez použitia počítača skúste zistiť, čo vypíše nasledujúci program. Pomôcka: vybudujte si tabuľku hodnôt funkcie f pre rôzne n a vypĺňajte ju od najmenších hodnôt n k väčším. Delenie dvomi v programe je celočíselné, vráti teda dolnú celú časť.

#include <iostream>
using namespace std;

int f(int n) {
    if(n<=5) return n;
    else {
        return (f(n-1) + f(n-3))/2;
    }
}


int main(void) {
    for(int i=1; i<=10; i++) {
        cout << i << ": " << f(i) << endl;
    }
}

Rekurzívne vykresľovanie korytnačou grafikou

Napíšte rekurzívny program, ktorý bude vykresľovať strom korytnačou grafikou. Strom má dva parametre: veľkosť d a stupeň n. Strom stupňa 0 je prázdna množina. Strom stupňa n pozostáva z kmeňa, ktorý tvorí úsečka dĺžky n a z dvoch podstromov, ktoré sú stromy stupňa n-1, veľkosti d/2 a otočené o 30 stupnov doľava a doprava od hlavnej osi stromu (pozri obrázky nižšie). Pri vykresľovaní stromu sa s korytnačkou vráťte na miesto a otočenie, v ktorom ste začali (bez toho by sa len ťažko písala rekuzívna funkcia). Korytnačka teda prejde po každej vetve dvakrát, raz smerom dopredu a raz naspäť. Inšpirujte sa programom, ktorý korytnačou grafikou kreslí kochovu krivku z prednášky 9.

Strom stupňa 1
Strom stupňa 2
Strom stupňa 3
Strom stupňa 5

Hanojské veže

Napíšte program, ktorý vypisuje priebeh riešenia Hanojských veží, t.j. po každom ťahu vypíše obsah jednotlivých tyčiek. Hanojská veže sme robili na prednáške 9.

Hanojské veže ešte raz

Vyriešte problém Hanojských veží s dodatočnou podmienkou, že nie je povolené priamo presunúť žiaden kameň z A na C. Preneste teda vrchné kamene z A na C (bez použitia priamych posunov medzi A a C), potom presuňte spodný kameň na B, potom presuňte horné kamene na A a spodný kameň na C. Nakoniec presuňte vrchné kamene na C (opäť bez použitia priamych presunov z A na C).

Prednáška 12

Organizačné poznámky

DÚ5 odovzdávajte do dnes (4.11.) 22:00.
DÚ6 odovzdávajte do piatka 8.11. 22:00.
Pokročilá DÚ2 tiež do piatka 8.11. 22:00.

Ukazovateľ, smerník, pointer

Pamäť v počítači je rozdelená na dieliky, do ktorých sa zapisujú hodnoty premenných
Väčšinou k týmto dielikom pristupujeme pomocou mien premenných
Každý dielik má adresu (niečo ako poradové číslo)
Ukazovateľ (resp. smerník alebo pointer) je premenná, ktorej hodnota je adresa iného dieliku pamäte

Definovanie premennej typu ukazovateľ

Nový ukazovateľ je definovaný pomocou typu s pridanou *

int i;      // klasická celočíselná premenná
int *pi;   // ukazovateľ na celočíselnú premennú

Typ ukazovateľa je teda rôzny pre rôzne typy premenných
- nedá sa priraďovať navzájom napr. ukazovateľ na int a ukazovateľ na char

int *pi;
char *pc;
pc = pi;     // chyba

Operátor & (adresa)

Adresu nejakej premennej vieme zistiť operátorom &
Tú potom môžeme priradiť do premennej typu ukazovateľ
Ak do premennej typu ukazovateľ nič nepriradíme, má nedefinovanú hodnotu, ukazuje na náhodné miesto v pamäti, alebo niekde mimo

int i;
int *pi = &i;

Premenná pi teraz ukazuje na miesto, kde je uložené i

Smerník, ktorý nikam neukazuje

Nulový ukazovateľ NULL - konštanta definovaná v knižnici cstdlib
Je možné priradiť ho ukazovateľom na ľubovoľný typ
Testovanie: if (pi == NULL) {...}
V C++ môžeme používať namiesto NULL aj 0.

Operátor * (dereferencovanie, údaje na adrese)

Ak máme ukazovateľ x, dáta z adresy, na ktorú ukazuje, získame ako *x
- Môžeme ich aj meniť

    int i = 1;
    int j = 2;
    int *p = &i;         // p ukazuje na i 
    cout << *p << endl;  // vypise 1
    p = &j;              // p ukazuje na j
    cout << *p << endl;  // vypise 2
    (*p)++;              // zvysime j o 1
    cout << *p << endl;  // vypise 3
    cout << j << endl;   // vypise 3

Príklady

Do premennej typu smerník na niečo môžeme priradiť iba adresu premennej typu niečo (alebo NULL).

int i, *p_i;

p_i = &i;       // spravne
p_i = &(i + 3); // zle, i+3 nie je premenna
p_i = &15;      // zle, konstanta nema adresu
p_i = 15;       // zle, priradovanie intu do adresy
i = p_i;        // zle, priradovanie adresy do intu
i = &p_i;       // zle, priradovanie adresy do intu
i = *p_i;       // spravne ak p_i bol inicializovany
*p_i = 4;       // spravne ak p_i bol inicializovany

Smerníky na struct

Smerník môže ukazovať aj na struct

struct kruh {
  int x, y, r;
};
kruh k;
k.x = 0; k.y = 0; k.r = 10;  // kruh na suradnicicach (0,0) s polomerom 10
kruh *p = &k;                // smernik na strukturu typu kruh 
(*p).x = 20;                 // dve formy priradovania do sucasti structu
p->y = 10;               
                             // k je teraz na suradniciach (20,10)

Pozor, bodka má vyššiu prioritu ako hviezdička

preto *p.x znamená *(p.x), teda vezmeme hodnotu v p.x, interpretujeme ju ako adresu a pozrieme sa, čo je na tejto adrese
- aký typ by muselo mať p aby toto fungovalo?
väčšinou chceme skôr (*p).x, čo znamená, že interpretujeme p ako adresu na struct, v ktorom je položka x
keďže sa to často používa, existuje skratka p->x

Parametre funkcií

Odovzdávanie hodnotou: nakopíruje hodnotu do novej lokálnej premennej

void nasob(int x) {
    x = 2*x;
    cout << x;
}
int main(void){
    int x = 1;
    nasob(x);   // vypise 2
    cout << x;  // vypise 1
}

Odovzdávanie referenciou: vytvorí nové meno pre existujúcu premennú, zmeny zostávajú aj po skončení

void nasob(int &x) {
    x = 2*x;
    cout << x;
}
int main(void){
    int x = 1;
    nasob(x);   // vypise 2
    cout << x;  // vypise 2
}

Nové: parameter je smerník
- Volajúca funkcia pošle smerník, ten sa hodnotou skopíruje do lokálnej premennej
- Ak ale robíme zmeny na adrese uloženej v parametri, majú dosah aj mimo funkcie

void nasob(int *p_x) {
    *p_x = *p_x * 2;
    cout << *p_x;
}
int main(void){
    int x = 1;
    nasob(&x);   // vypise 2
    cout << x;   // vypise 2
}

V čistom C neboli referencie, týmto spôsobom sa odovzdávajú premenné, ktoré sa majú meniť
- Stále používané v C-čkových štandardných knižniciach

Funkcia swap s použitím ukazovateľov

void swapP(int *p_x, int *p_y){ // ako parameter má dve adresy ukazujúce na celé čísla
    int pom = *p_x;             // do premennej pom nastavi hodnotu, ktorá je na adrese p_x                 
    *p_x = *p_y;                // hodnotu, ktorá je na adrese p_x zmení na hodnotu, ktorá je na adrese p_y 
    *p_y = pom;                 // hodnotu, ktorá je na adrese p_y nastaví na hodnotu premennej pom
}

Ako budeme túto funkciu volať, ak chceme vymeniť hodnoty premenných i=5 a j=7?

swapP(i, j); Zle. Vymieňame obsahy adries 5 a 7. Neskompiluje, lebo int sa nedá priradiť do int *
swapP(*i, *j); Zle. Vymieňame obsahy adries uložených na adresách 5 a 7. Neskompiluje lebo operátor * sa nedá použiť na premenné typu int.
swapP(&i, &j); Správne. Pošle adresy premenných i a j a funkcia swapP vymení hodnoty na týchto adresách.

Dynamická alokácia a dealokácia pamäte: new, delete

Doteraz sme videli

globálne premenné: majú vopred známu veľkosť a vyhradenú pamäť
lokálne premenné: majú vopred známu veľkosť, ale nevieme, ktoré funkcie sa použijú (a v prípade rekurzie koľkokrát), preto sa im pamäť priraďuje až pri volaní funkcie na zásobníku funkčných volaní (call stack)

Teraz si ukážeme, ako môže si program vyhradiť počas behu ďalšiu pamäť podľa potreby

Používa sa na to príkaz new
Pamäť sa vyhradí v oblasti zvanej heap (halda, hromada)
Keď už pamäť nepotrebujeme, uvoľníme ju príkazom delete
Uvoľnená pamäť môže byť znovu použitá pri ďalších volaniach new

#include <iostream>
using namespace std;

int main(void){
    int * p;       // p je lokalna premenna, zatial neinicializovana
    p = new int;   // vypytam si novy kus pamate dost velky na 1 int
                   // a adresu ulozim do p
   
    *p = 50;       // do alokovanej pamati ulozim hodnotu 50 
    cout << *p << endl;  // vypisem 50
    delete p;     // alokovanu pamat uvolnim
}

Príklad využitia new a delete

Máme štruktúru kruh, chceme od užívateľa načítať niekoľko kruhov
Nevieme, koľko ich bude, tak si spravíme pole smerníkov a naalokujeme len potrebné kruhy

#include <iostream>
#include <cstdlib>
using namespace std;

struct kruh {
    int x, y, r;
};

const int maxN = 100;
const double pi = 3.1415926536;

int main(void) {
    kruh * kruhy[maxN];
    int n;
    cout << "Zadajte pocet kruhov: ";
    cin >> n;

    for (int i = 0; i < n; i++) {
        cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": ";

        /* vytvorime novy kruh */
        kruh * novy = new kruh;
        cin >> novy->x >> novy->y >> novy->r;

        /* ulozime adresu noveho kruhu do pola */
        kruhy[i] = novy;
    }

    /* spracovavame zoznam kruhov, napr. spocitame sucet ich obsahov */
    double sucet = 0;
    for (int i = 0; i < n; i++) {
        sucet += kruhy[i]->r * kruhy[i]->r * pi;
    }
    cout << "Sucet obsahov kruhov: " << sucet << endl;

    /* na konci zmazeme kruhy */
    for (int i = 0; i < n; i++) {
        delete kruhy[i];
    }
}

Všimnite si:

kruh * kruhy[maxN]; vytvorí pole smerníkov na kruh s maxN prvkami
Prístup k polomeru i-teho kruhu: kruhy[i]->r

Problém: pole kruhy má aj tak vopred stanovenú veľkosť, je však možné alokovať aj polia dynamickej veľkosti.

Cvičenie: Prečo nemôžeme v programe zmeniť načítanie takto?

    kruh novy;

    for (int i = 0; i < n; i++) {
        cout << "Zadajte suradnice stredu a polomer kruhu " << i << ": ";

        /* nacitame kruh */
        cin >> novy.x >> novy.y >> novy.r;

        /* ulozime adresu noveho kruhu do pola */
        kruhy[i] = &novy;
    }

Polia a smerníky

Polia a smerníky v jazyku C spolu veľmi úzko súvisia.
Pole sa správa (väčšinou) ako ukazovateľ na jeho prvý prvok.

Vezmime tento jednoduchý program s funkciou, ktorá vypíše obsah poľa

void vypisPole(int a[], int n) {
    for(int i=0; i<n; i++) {
        cout << a[i];
    }
}

int main(void) {
    int a[3] = {0,1,2};
    vypisPole(a, 3);
}

Hlavičku funkcie môžeme zmeniť takto a všetko bude ďalej fungovať:

void vypisPole(int *a, int n) {

Tiež do premennej typu int * môžeme priradiť pole. Premenná bude potom fungovať ako smerník na prvý (presnejšie nultý) prvok poľa.

 int a[3] = {0,1,2};
 int *b = a;
 vypisPole(b, 3);

Alokovanie jednorozmerného poľa

Operátor new má verziu, ktorá alokuje pole zadanej dĺžky
Napr. int *a = new int[10];
Výsledok priradíme do ukazovateľa, odvtedy používame ako pole
Uvoľníme operátorom delete[].
Veľkosť poľa v new nemusí byť konštanta, môžeme si naalokovať také veľké pole, ako potrebujeme

Napríklad od užívateľa načítame počet čísel, vytvoríme pole príslušnej veľkosti a načítame do neho čísla:

Podobne by sa dal zmeniť aj program s kruhmi vyššie

#include <iostream>
using namespace std;

int main(void) {
    cout << "Zadaj pocet cisel: ";
    int n;
    cin >> n;
    int *a = new int[n];   // vytvorime pole

    for (int i = 0; i < n; i++) {  // nacitame data
        cout << "Zadaj cislo " << i << ": ";
        cin >> a[i];
    }
    for (int i = n-1; i >=0; i--) {  // spracujeme, napr. vypiseme odzadu
        cout << a[i] << endl;
    }
    delete[] a;
}

Kontrola programov nástrojom valgrind

C-čko pri použití polí a smerníkov nekontroluje, či ich používame správne
Chybou v programe sa nám teda ľahko môže stať, že čítame alebo píšeme mimo alokovanej pamäte
Takéto chyby sa niekedy ťažko hľadajú
V Linuxe nám na hľadanie takýchto chýb pomôže nástroj valgrind

Keď v Netbeans spustíme nástroj Build (ikonka kladivka; spúšťa sa tiež automaticky pred spustením programu), Netbeans zavolá kompilátor a vytvorí spustiteľný súbor
Tento spustiteľný súbor nájdeme v adresári typu NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/, volá sa rovnako ako projekt
V Linuxe si ho môžeme na príkazovom riadku spustiť aj mimo prostredia Netbeans, stačí napísať NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu
Namiesto toho ho môžeme spustiť valgrind NetBeansProjects/meno_projektu/dist/Debug/GNU-Linux-x86/meno_projektu
Nástroj valgrind bude náš program pozorne sledovať a keď robí divné veci v pamäti, vypíše nám o tom správu

Nasledujúci program vypisuje neinicializovanú premennú i (knižnice pre krátkosť vynechávame):

int main(void) {
    int i; cout << i << endl;
}

Valgrind vypíše okrem iného

==6021== Conditional jump or move depends on uninitialised value(s)
==6021==    at 0x4EBAD23: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x40079A: main (main.cpp:7)
==6021== 
==6021== Use of uninitialised value of size 8
==6021==    at 0x4EBA823: ??? (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x4EBAD47: std::ostreambuf_iterator<char, std::char_traits<char> > std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::_M_insert_int<long>(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x4EBB065: std::num_put<char, std::ostreambuf_iterator<char, std::char_traits<char> > >::do_put(std::ostreambuf_iterator<char, std::char_traits<char> >, std::ios_base&, char, long) const (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x4EC64DC: std::ostream& std::ostream::_M_insert<long>(long) (in /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.16)
==6021==    by 0x40079A: main (main.cpp:7)

Nasledujúci program zapisuje do pamäte, na ktorú ukazuje smerník s neinicializovnaou hodnotou

int main(void) {
    int *p; 
    *p = 7; 
    cout << *p << endl;
}

==6125== Use of uninitialised value of size 8
==6125==    at 0x400790: main (main.cpp:7)
==6125== 
==6125== Invalid write of size 4
==6125==    at 0x400790: main (main.cpp:7)
==6125==  Address 0x0 is not stack'd, malloc'd or (recently) free'd
==6125== 
==6125== 
==6125== Process terminating with default action of signal 11 (SIGSEGV)
==6125==  Access not within mapped region at address 0x0
==6125==    at 0x400790: main (main.cpp:6)

Tento program sa pokúša odalokovať pamäť, ktorá nebola alokovaná

int main(void) {
    int i = 7; 
    int *p = &i; 
    delete p;
}

==6579== Invalid free() / delete / delete[] / realloc()
==6579==    at 0x4C2A4BC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==6579==    by 0x400696: main (main.cpp:8)
==6579==  Address 0x7ff00097c is on thread 1's stack

Ani valgrind nemusí nájsť všetky chyby, napr. tu sa k premennej správame ako ku poľu a píšeme mimo, ale valgrind si to nevšimne:

int main(void) {
    int i;
    int *p = &i; 
    p[2] = 7;
    cout << p[2] << endl;
}

Ak index 2 nahradíme 2000, valgrind už vypíše chybu...

Smerníková aritmetika

Pole je vlastne smerník na svoj prvý prvok
Majme napr. pole int a[4] = {4, 3, 2, 1};
K i-temu prvku sa vieme dostať pomocou a[i]
Dá sa to však napísať aj ako *(a+i)
Konkrétne a+i je smerník na i-ty prvok poľa a
Kompilátor spočíta veľkosť jedného políčka poľa, takže vie, ako ďaleko sa posunúť, aby sa dostal na i-te políčko
int *b = a+2 vytvorí smerník na a[2], ale k b sa môžeme správať ako ku dvojprvkovému poľu {2, 1}

Smerníková aritmetika:

smerník + n: Posun smerníka o n. Ak napríklad smerník ukazuje na 0. prvok poľa, smerník + n bude ukazovať na n-tý prvok poľa.
- Ak chceme zvýšiť smerník o 1 môžeme použiť smerník++.
smerník - n: Posun smerníka o n prvkov smerom k začiatku.
smerník1 - smerník2: Výsledkom rozdielu smerníkov je vzdialenosť miest, na ktoré ukazujú. Ak napríklad prvý smerník ukazuje na 5. prvok poľa a druhý smerník na 3. prvok poľa, ich rozdiel je 2. Smerníky musia patriť do toho istého poľa, inak bude výsledok nedefinovaný.

Porovnávanie ukazovateľov:

operátory: < <= > >= == !=
porovnávanie má zmysel len keď ukazovatele:
- sú rovnakého typu
- ukazujú do toho istého poľa

Tu je napr. zvláštny spôsob ako vypísať pole a definované vyššie:

for (int *smernik = a; smernik < a + 4; smernik++) {
     cout << "Prvok " << smernik - a << " je " << *smernik << endl;
}

Podobný kód sa ale občas používa na prechádzanie reťazcov, napr. ak chceme zrátať počet medzier v reťazci:

int zratajMedzery(char str[]) { // mohli by sme dat aj char *str
  int pocet = 0;
  while(*str != 0) {   // kym nenajdeme ukoncovaciu nulu v retazci
     if(*str==' ') { pocet++; }  // skontroluj znak, na ktory ukazuje smernik
     str++;                      // posun smernik na dalsi znak 
  }
  return pocet;
}

Funkcie z knižnice cstring s reťazcovou aritmetikou

strstr(text, vzorka) vracia smerník na char
- NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak
- pozíciu výskytu zistíme smerníkovou aritmetikou:

char *text, *vzorka;
char *where = strstr(text, vzorka);
if(where != NULL) {
  int position = where - text;
}

Ako by ste spočítali počet výskytov vzorky v texte?
Podobne strchr hľadá prvý výskyt znaku v texte

Zhrnutie

Smerník, ukazovateľ, pointer je premenná, v ktorej je uložená adresa nejakého pamäťového miesta
Typ smerníku určuje, na aký typ premennej by mal ukazovať, napr. int *p
Do smerníku môžeme priradiť NULL, adresu nejakej premennej (&i), novoalokovanú pamäť pomocou new, iný smerník toho istého typu
Ku políčku, na ktoré ukazuje smerník p, pristupujeme pomocou (*p)
Pole je vlastne smerník na svoj prvý (nultý) prvok
Pole určitej dĺžky (ktorá je známa až počas behu) alokujeme pomocou new typ[pocet]
Pamäť alokovanú cez new by sme mali odalokovať pomocou delete alebo delete[] (podľa toho, či to bolo pole)
Pri práci so smerníkmi ľahko spravíme chybu, pomôcť nám môže valgrind

Prednáška 13

Organizačné poznámky

DÚ6 a Pokročilú DÚ2 odovzdávajte do piatka 8.11. 22:00.
v stredu 6.11. cvičenia presunuté do vedľajšej miestnosti M218.

Práca so súbormi

Doteraz sme na načítavanie a vypisovanie dát používali výhradne konzolu (obrazovku/klávesnicu).
V praxi často chceme spracovávať dáta uložené v súboroch.
Zameriame sa na súbory v textovom formáte, pracuje sa s nimi podobne ako s konzolou.
V C++ existujú ekvivalenty cin >> a cout << aj pre súbory, nájdete ich v knižnici fstream.

Práca s konzolou v Cčku: printf a scanf

Teraz sa naučíme, ako sa so súbormi (a s konzolou) pracuje v klasickom Cčku.
Príkazy printf a scanf sú v knižnici cstdio

printf

Funkcia printf vypisuje formátovaný text na konzolu.
Použitie: printf(format, hodnota1, hodnota2,...)
Formátovací reťazec obsahuje bežné znaky, ktoré sa priamo vytlačia a špeciálne formátovacie príkazy začínajúce %, ktoré určujú, ako formátovať jednotlivé hodnoty
Napr. predpokladajme, že x a y sú celočíslené premenné s hodnotami 10 a 20. Príkaz printf("bod (%d,%d)\n", x, y) vypíše "bod (10,20)" a koniec riadku.

Príklady formátovacích reťazcov:

%c - znak (character)
%s - reťazec (string)
%d - celé číslo (integer)
%f - reálne číslo (double)
%e - reálne čislo vo vedeckej notácii napr. 5.4e7
%% - vypíše znak %

Pozor, typy výrazov v zozname hodnôt musia sedieť s formátovacím reťazcom

Formátovanie

Nastavovanie šírky a počtu desatinných miest

%.2f - vypíše na 2 desatinné miesta
%4d - ak má číslo menej ako 4 znaky, doplní vľavo medzery
%04d - podobne, ale dopĺňa nuly

Na predáške o stringoch sme videli formatovanie vysledku (zarovnanie doľava) pomocou vlastnej funkcie, ktorá číslo pripravila do pomocného poľa znakov (stringu).

int main(void) {
    char A[maxN];
    int n = 12;
    for (int i = 1; i <= n; i++) {
        int x = factorial(i);
        formatInt(i, A, 2);
        cout << A << "! = ";
        formatInt(x, A, 10);
        cout << A << endl;
    }
}

Vďaka formátovacím reťazcom v printf vieme tento program prepísať jednoduchšie.

int main(void) {
    int n = 12;
    for (int i = 1; i <= n; i++) {
        printf("%2d",i);
        printf("! = ");
        printf("%10d\n",factorial(i));
    }
}

Dokonca by nám v cykle stačil jediný príkaz printf("%2d! = %10d\n",i,factorial(i));
Podobne vieme doplniť aj úvodné nuly - napríklad, keď by sme radi v dátume doplnili deň a mesiac na dvojciferné čísla a rok na štvorciferné.

void showDate(int d, int m, int y){
    printf("%02d.%02d.%04d",d,m,y);
}

int main(void){
    showDate(1,1,1990);
}

scanf

Funkcia scanf(format, premenna1, premenna2,...) načítava dáta z konzoly
- Napr. scanf("%d", &x) načíta celočíselnú hodnotu do premennej x.
- Všimnite si, že zatiaľ čo do printf sa vkladajú priamo hodnoty (premenné), scanf potrebuje smerníky na premenné, pretože ich modifikuje.

Jednoduché načítanie mena a veku.

  char str [80];
  int i;

  printf ("Enter your family name: ");
  scanf ("%s",str);  
  printf ("Enter your age: ");
  scanf ("%d",&i);
  printf ("Mr. %s , %d years old.\n",str,i);

Formátovací reťazec obsahuje:
- Špecifikáciu formátov načítávaných premenných (začínajú znakom %) - podobne ako u printf
- Biele znaky ("whitespace" - medzery, konce riadkov, tabulátory) - funkcia číta a ignoruje všetky biele znaky pred ďalším nebielym znakom (jeden biely znak umožní ľubovoľný počet bielych znakov na vstupe)
- Ostatné znaky formátovacieho reťazca musia presne zodpovedať vstupu

Načítávanie dátumu.

  int d,m,y;

  printf("Enter the date: ");
  scanf("%d.%d.%d",&d,&m,&y); 
  printf("Year: %d\n",y);

Funkcia vracia počet úspešne priradených hodnôt (načítáva kým nedôjde k chybe vstupu alebo chybe konverzie na príslušný typ premennej). V prípade chyby hneď na začiatku vracia hodnotu EOF (napríklad hneď na začiatku končí vstup).

Postupné sčítávanie čísel zo vstupu.

  double sum, v;

  sum = 0;
  while (scanf("%lf", &v) == 1)
    printf("%.2f\n", sum += v);

Kontrola správneho vstupu

Určenie, či máme na vstupe potrebný počet čísel na nejakú operáciu

Program načíta zo súboru tri double čísla a vypíše ich na obrazovku - testuje, či sú v súbore 3 čísla

int main() {
   double x, y, z;

   if(scanf("%lf %lf %lf", &x, &y, &z) == 3)
      printf("%lf \n", x + y + z);
   else 
      printf("Neboli nacitane 3 realne cisla\n.");
}

Kontrola celého čísla, záporného čísla, desatinného čísla, pre vhodné číselné sústavy kontrola čísla
Pomocou scanf, však vieme robiť iba jednoduché kontroly chýb. Môže byť preto lepšie najprv načítať zo vstupu reťazec pomocou gets a prečítaný string následne spracovať. Ale o tom až na ďalšej prednáške.

Práca so súborom: FILE *, fopen, fclose, fprintf, fscanf

Základný dátový typ: FILE *

ukazovateľ (pointer - *) na objekt typu FILE
dodržať veľké písmená (FILE *, nie file *)
obsahuje údaje o otvorenom súbore, s ktorým práve pracujeme
definícia premennej f pre prácu so súborom FILE *f; (pre viac premenných FILE *fr, *fw;)

Otvorenie súboru pre čítanie

fr = fopen("vstup.txt", "r");
Otvorí súbor s menom vstup.txt (môžeme samozrejme použiť aj iné meno, prípadne pridať cestu)
Ak taký súbor neexistuje alebo sa nedá otvoriť, do fr priradí NULL
Z takto otvoreného súboru môžeme čítať napr. pomocou fscanf, ktorá je analógom scanf
Napr. fscanf(fr, "%d", &x);

Otvorenie súboru pre zápis

fw = fopen("vystup.txt", "w");
Vytvorí súbor s menom vystup.txt. Ak už existoval, zmaže jeho obsah.
Ak sa nepodarí súbor otvoriť, do fw priradí NULL.
Do takto otvoreného súboru môžeme zapisovať napr. pomocou fprintf, ktorá je analógom printf
Napr. fprintf(fw, "%d", x);

Zatvorenie súboru

Keď už nebudeme zo súboru čítať ani doňho zapisovať, uzatvoríme ho pomocou fclose(f);
Nespoliehať sa, že po skončení programu sa súbor automaticky zavrie súbor
Počet súčasne otvorených súborov je obmedzený
Pri zavretí sa zapíše buffer do súboru, predídeme tým strate dát pri páde programu
Ak sa nepodarí otvoriť súbor - vracia fclose() konštantu EOF

V súbore vstup.txt máme niekoľko riadkov, prvý obsahuje názov výstupného súboru a každý ďalší obsahuje názov súboru (označme f) a číslo (označme x). Do výstupného súboru chceme pre každý riadok zo vstupu vypísať zo súboru f prvých x čísel.

Príklad: Súbor a.txt obsahuje čísla 1..9, súbor b.txt obsahuje čísla 10,20..90 a súbor c.txt obsahuje čísla 100,200..900.

Pre vstupný súbor vstup.txt

vystup.txt
a.txt 2
b.txt 1
a.txt 3

Očakávame výstup v súbore vystup.txt

1 2 10 1 2 3

Otvoríme vstupný súbor a prečítame z neho názov výstupného súboru
Otvoríme aj výstupný súbor a postupne budeme zo vstupu čítať dvojice subor cislo.
- Každý načítaný súbor si otvoríme, vypíšeme z neho čísla a zatvoríme.
Na konci zavrieme vstup aj výstup.
Kontrolujeme existenciu súborov aj čísel v nich.

int main() {
    FILE *fr1, *fr2, *fw;
    char str[20];
    int kolko,cislo; 

    fr1=fopen("vstup.txt","r");
    if (!fr1) return -1;
    if (fscanf(fr1,"%s",str)!=1) return -1;
    fw=fopen(str,"w");
    if (!fw) return -1;
    while (!feof(fr1)){
        fscanf(fr1,"%s %d",str,&kolko);
        fr2=fopen(str,"r");
        if (!fr2) return -1;
        for (int i=0; i<kolko; i++){
            if (fscanf(fr2,"%d ",&cislo)!=1) return -1;
            fprintf(fw,"%d ",cislo);
        }
        fclose(fr2);
    }
    fclose(fr1);
    fclose(fw);
}

Štandardný vstup a výstup ako súbor

C pracuje s klávesnicou a obrazovkou ako so súborom - v stdio.h sú definované dva konštantné ukazovatele stdin a stdout.

FILE *stdin, *stdout;

označujú štandardný vstupný/výstupný prúd (standard intput-output stream)
stdin a stdout môžu byť použité v programe ako argumenty operácií so súbormi fscanf(stdin,"%d",&x)

Vďaka tomu, že aj štandardný vstup a výstup sa dajú používať v takým istým spôsobom ako súbory je, že si používateľ môže vybrať, s čím chce pracovať.

V prípade, že by sme v predchádzajúcom príklade chceli na základe prvého riadku vstupu umožniť aj umožniť zapisovanie na štandardný výstup (napríklad ak je na vstupe "-"), stačilo by pred otvorením výstupu overiť túto alternatívu a ďalej pracovať rovnako.

...
    if (fscanf(fr1,"%s",str)!=1) return -1;
    if (strcmp(str,"-")==0) fw=stdout;
    else fw=fopen(str,"w");
    if (!fw) return -1;
...

Testovanie konca súboru

Pomocou symbolickej konštanty EOF
- definovaná v stdio.h, väčšinou má hodnotu -1
Pomocou makra feof()

Binárne súbory

Ako ukladať desatinné čísla?

Strata presnosti

A čo väčšie štruktúry?

Nanútime pre všetkých spôsob načítávania

Alternatívne riešenie je použitie binárnych súborov, kde sa neukladáme textovú reprezentáciu ale reprezentáciu, ktorá zodpovedá uloženiu v pamäti.

fwrite

Funkcia fwrite( const void * ptr, size_t size, size_t count, FILE * f ); do súboru f zapíše count položiek veľkosti size ležiacich v pamäti od adresy ptr.
- Funkcia vráti počet reálne zapísaných položiek.
- Súbor f musí byť otvorený na zápis.
Typickým príkladom je, že mám určité položky uložené v poli. Potom začiatok pamäte je určený smerníkom.

Príklad: Chceme uložiť pole reálnych čísel (napríklad odmocniny z čísel 0..100).

int main() {

    double a[100];
    FILE *f;
    double b[5];

    
    for (int i=0; i<100; i++) a[i]=sqrt(i);
    
    f=fopen("binarny.dat","w");
    fwrite(a,sizeof(double),100,f);
    fclose(f);
    
}

fread

fread funguje podobne ako fwrite.
Funkcia fread (void * ptr, size_t size, size_t count, FILE * f ); zo súboru f prečíta count položiek veľkosti size a uloží ich do pamäti od adresy ptr.

Ak by sme si chceli napríklad overiť, že súbor z predchádzajúceho príkladu naozaj obsahuje na 4. mieste číslo 2, stačí si do poľa b uložiť prvých 5 položiek zo súboru binarny.dat a skontrolovať prvok b[4].

int main() {

    FILE *f;
    double b[5];
    
    f=fopen("binarny.dat","r");
    fread(b,sizeof(double),5,f);
    printf("%f\n",b[4]);
    fclose(f);
}

Spracovávanie vstupu

V prípade, že máme v súbore zaručené čísla, bežne bývajú v niektorom z nasledujúcich formátov:

N (počet čísel) a za tým N čísel

    FILE *f;
    int a[100],N,i,x;
    int sum=0;

    f=fopen("vstup.txt","r");
    if (!f) return -1;

    if (fscanf(f,"%d ",&N)!=1) return -1;
    
    for (int i=0; i<N; i++){ 
        if (fscanf(f,"%d ",&a[i])!=1) return -2;
        sum+=a[i];
    }

    printf("%d\n",sum);
    fclose(f);
}

postupnosť čísel ukončená -1 alebo inou špeciálnou hodnotu

int main() {

    FILE *f;
    int a[100],N,i,x;
    int sum=0;

    f=fopen("vstup.txt","r");
    if (!f) return -1;

    i=0;
    if (fscanf(f,"%d ",&x)!=1) return -2;
    while (x!=-1){
        a[i++]=x;
        sum+=x;
        if (fscanf(f,"%d ",&x)!=1) return -2;        
    }

    printf("%d\n",sum);
    fclose(f);
}

čísla až kým neskončí súbor
- teoreticky by sme mohli kontrolovať či sa správne načítalo, teda while (fscanf(f,"%d ",&x)==1)){...}, ale nerozoznali by sme správny koniec od chyby

int main() {

    FILE *f;
    int a[100],N,i,x;
    int sum=0;

    f=fopen("vstup.txt","r");
    if (!f) return -1;

    i=0;
    while (!feof(f)){
        if (fscanf(f,"%d ",&a[i])!=1) return -1;
        sum+=a[i++];
    }
    
    printf("%d\n",sum);
    fclose(f);
}

niekoľko sád z predchádzajúcich vecí

Cvičenia 7

Backtracking, prehľadávanie s návratom

Napíšte rekurzívny program, ktorý pre dané čísla n a k (1<=k<=n) vypíše všetky podmnožiny veľkosti k množiny {0..n-1}. Na rozdiel od variácií nám v podmnožine nezáleží na poradí (napr. {0,1} = {1,0}), prvky teda budeme vždy vypisovať od najmenšieho po najväčší. Napr. pre n=3 a k=2 vypíšte

0 1
0 2
1 2

Napíšte program, ktorý pre dané čísla n, k a S vypíše všetky k-tice čísel z množiny {0..n-1}, ktorých súčet je aspoň S. Prehľadávanie zastavte vždy, keď nie je možné súčet S dosiahnuť, ani keby všetky zvyšné čísla mali hodnotu n-1. Napríklad pre k=3, n=3, S=5 vypíšte

Čítanie programov

Skúste zistiť bez použitia počítača, čo vypíše nasledujúca funkcia, ak ju spustíme ako generuj(a, pocet, 0, 2, 3), pričom polia a a pocet majú dĺžku n=3 a obe sú naplnené nulami. Funkcia vypis(a,n) vypíše prvky poľa a.
Ako musíme funkciu opraviť, aby vypisovala všetky usporiadané n-tice čísel z množiny {0,...,n-1}, v ktorých sa každé číslo opakuje najviac k krát?

void generuj(int a[], int pocet[], int i, int k, int n) {
    if (i == n) {
        vypis(a, n);
    } else {
        for (int x = 0; x < n; x++) {
            if (pocet[x]<k) {
                a[i] = x;
                pocet[x]++;
                generuj(a, pocet, i + 1, k, n);
            }
        }
    }
}

Grayov kód

Vypíšte všetky k-tice binárnych hodnôt 0 a 1 tak, aby sa každé dve po sebe idúce k-tice sa líšili na najviac jednom mieste a tiež posledná k-tica s prvou, ako v tomto príklade:

Takáto postupnosť sa nazýva Grayov kód. Ako vidno v tomto príklade, Grayov kód stupňa k sa dá zostaviť rekurzívne: horná polovica kódu stupňa k je Grayov kód stupňa k-1 s cifrou 0 pridanou na najľavejšiu pozíciu a druhá polovica kódu stupňa k je kód stupňa k-1 vypísaný odzadu s cifrou 1 pridanou na najľavejšiu pozíciu. Môžete použiť nasledovnú hlavičku rekurzívnej funkcie:

void gray(int a[], int k, int i, bool reverse) {
  /* Prvych i pozicii v poli a obsahuje hodnoty 0 a 1,
   * Do zvysnych k-i postupne dosadte Grayov kod stupna k-i
   * a zakazdym vypiste cele pole. 
   * Ak reverse = true, Grayov kod generujte odzadu. */
}

Quicksort

Upravte funkciu partition v quicksorte tak, aby rozdelila pole na tri časti: v ľavej časti budú prvky menšie ako pivot, v strednej prvky rovné pivotu a v pravej prvky väčšie ako pivot. Funkcia vráti pomocou parametrov odovzdávaných referenciou polohu začiatku a konca strednej časti. V hlavnej rekurzívnej časti quicksortu sa potom spustí rekurzia iba na ľavú a pravú časť poľa; všetky kópie pivota sú už na svojom mieste. Ak má vstupné pole veľa rovnakých prvkov, môže sa nám takto podariť viacero prvkov rovných pivotu rovno umiestniť na svoje miesto.

Vaša nová funkcia partition môže pracovať napríklad takto:

na indexoch low..lastLeft sú prvky menšie ako pivot
na indexoch firstRight..high sú prvky väčšie ako pivot
v ďalších premenných si udržiavate hodnotu pivota a počet prvkov rovných pivotu

Po správnej inicializácii všetkých premenných prechádzate poľom a buď nový prvok pôjde do ľavej časti a zvýšite lastLeft, alebo do pravej časti a znížite firstRight, alebo zvýšite počet prvkov rovných pivotu. Pozor, pri presunutí prvku do pravej časti poľa sa musíme vysporiadať aj s prvkom, ktorý bol pôvodne na jeho mieste. Po skončení cyklu jednoducho všetko medzi lastLeft a firstRight vyplníte hodnotu pivota.

Prednáška 14

Organizačné poznámky

DÚ7 odovzdávajte do piatka
PDÚ3 a DÚ8 budú zverejnené tento týždeň

Súbory, zhrnutie

Príkazy fopen, fclose na otváranie a zatváranie súboru, typ FILE *
Príkazy fscanf a fprintf na načítavanie a vypisovanie formátovaných dát (čísla, slová)

Príklad: načítame číslo n a n celých čísel zo súboru vstup.txt. Do súboru vystup.txt vypíšeme n a vstupné čísla v opačnom poradí.

#include <cstdio>
#include <cassert>

int main(void) {
    FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny a vystupny subor
    FILE *fw = fopen("vystup.txt", "w");
    assert(fr != NULL && fw != NULL); // skontrolujeme, ze sa podarilo

    int n, r;
    r = fscanf(fr, "%d ", &n); // nacitame pocet prvkov n
    assert(r == 1 && n >= 0); // overime, ze s apodarilo a ze pocet nezaporny
    int *a = new int[n]; // alokujeme pole dlzky n

    for (int i = 0; i < n; i++) { // citame jednotlive prvky pola
        r = fscanf(fr, "%d ", &a[i]);
        assert(r == 1);
    }
    fclose(fr); // zavrieme vstupny subor

    fprintf(fw, "%d", n); // vypiseme pocet prvkov do vystupu
    for (int i = n - 1; i >= 0; i--) { // vypiseme vstupne prvky naopak
        fprintf(fw, " %d", a[i]);
    }
    fclose(fw); // zavrieme vystupny subor
    delete[] a; // uvolnime pamat
}

printf a scanf sú podobné, ale pracujú s konzolou (stdin, stdout)
existujú aj funkcie sscanf, sprintf, ktoré načítavajú resp. vypisujú do reťazca

Práca so súbormi po znakoch

Čítanie po znakoch: funkcia getc(subor) načíta zo súboru jeden znak.

Vracia int (nie char).
Ak sa podarilo načítať, je to kód načítaného znaku.
Ak sa nepodarilo načítať znak (koniec súboru, alebo nejaká chyba), vráti špeciálnu hodnotu EOF
- Pozor, neukladať výsledok do premennej typu char, nevedeli by sme rozpoznať koniec súboru, bol by konvertovaný na iný znak
Funkcia getchar() je skratka za getc(stdin), číta teda jeden znak z konzoly
- Spracovanie vstupu z klávesnice začne až potom, ako užívateľ stlačí Enter, nevieme takto reagovať priamo na stlačenie nejakej klávesy

Písanie po znakoch: funkcia putc(znak, subor) zapíše do súboru jeden znak

Vracia int: zapísaný znak alebo EOF ak nastala chyba
Funkcia putchar(znak) je skratka za putc(znak, stdout), píše teda na konzolu

Príklad: kopírovanie súboru

#include <cstdio>
int main(void) {
   FILE *fr = fopen("list.txt", "r");
   FILE *fw = fopen("kopia.txt", "w");

   int c = getc(fr);
   while (c != EOF) {
      putc(c, fw);
      c = getc(fr);
   }

   fclose(fr);
   fclose(fw);
}

Načítavať môžeme aj priamo v podmienke while cyklu:

výsledkom priradenia je nová hodnota, túto porovnáme s EOF
kratšie ale trochu menej čitateľné

   int c;
   while ((c = getc(fr)) != EOF) {
      putc(c, fw);
   }

Konce riadkov

Znak pre koniec riadku je '\n'

pri čítaní alebo zápise sa môže prekladať na jeden alebo dva znaky podľa typu operačného systému (<CR>, <LF>, alebo <CR><LF>)

Čo robí nasledujúci program?

#include <cstdio>

int main(void) {
   FILE *fr;
   int c;

   fr = fopen("VSTUP.TXT", "r");
   while ((c = getc(fr)) != '\n') {
      putchar(c);
   }
   putchar(c);    /* vypis \n */
   fclose(fr);
}

Ungetc

Často zistíme, že máme prestať čítať znak až potom, čo prečítame o znak naviac

funkcia ungetc(znak, subor) vráti znak späť (ako keby sme ho neprečítali)
ak je vrátenie úspešné, ungetc() vracia vrátený znak
ak je vrátenie neúspešné, vráti EOF
vrátiť môžeme aj iný ako práve prečítaný znak
- použije sa pri ďalšom načítaní, ale nezmení obsah súboru
nemali by sme volať viackrát za sebou

Program konvertuje znakový reťazec na zodpovedajúcu číselnú hodnotu. Keď narazí na prvý znak, ktorý nie je cifra, vráti ho, aby sa dal použiť pri ďalšom spracovávaní.

    int hodnota = 0;
    int c = getchar();
    while (c >= '0' && c <= '9') {
        hodnota = hodnota * 10 + (c - '0');
        c = getchar();
    }
    ungetc(c, stdin);

Program prečíta číslo pomocou fscanf, predtým však musí prečítať neznámy počet znakov '$'.

#include <cstdio>
int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int c = getc(fr);
    while (c == '$') {
        c = getc(fr);
    }
    ungetc(c, fr);

    int hodnota;
    fscanf(fr, "%d", &hodnota);
    printf("%d\n", hodnota);
    fclose(fr);
}

Čítanie a písanie po riadkoch

Funkcia fgets(str, n, subor) načíta riadok zo súboru

str je pole char-ov (premenná typu char *)
n je veľkosť tohto poľa (aby funkcia neprepísala miesto mimo poľa)
Funkcia načíta do str jeden riadok súboru, ale ak by bol príliš dlhý, skončí po prvých n-1 znakoch
Znak '\n' nechá na konci poľa, za neho dá ukončovaciu 0
Skončí aj ak príde na koniec súboru
Vráti str, alebo NULL ak sa nepodarilo načítať ani jeden znak (vracia teda char *)

Nasledujúci program spočíta počet riadkov v súbore

Čo spraví, ak posledný znak súboru nie je koniec riadku?
Čo vypíše pre súbor, ktorý obsahuje jeden riadok s 200 znakmi?

#include <cstdio>
int main(void) {
    const int maxN = 100;
    char str[maxN];
    FILE *fr = fopen("vstup.txt", "r");
    int num = 0;
    while (fgets(str, maxN, fr) != NULL) {
        num++;
    }
    cout << num << endl;
}

Funkcia fputs(str, subor) vypíše reťazec str do súboru

str môže obsahovať hocikoľko koncov riadkov (aj nula)
pri chybe vráti EOF

Spracovávanie vstupu

Časté schémy spracovania textového súboru:

Pomocou fscanf načítavame jednotlivé čísla, slová a pod. (väčšinou všetky biele znaky považujeme za ekvivalentné oddeľovače)
Čítanie po znakoch pomocou getc
Čítanie po riadkoch pomocou fgets do reťazca, potom reťazec spracovávame

Príklad: chceme nájsť dĺžku najdlhšieho riadku v súbore

Prvá možnosť je čítanie riadkov do reťazca a ich spracovanie (problém ak je riadok príliš dlhý)
Druhá možnosť je čítať súbor po znakoch, pričom si potrebujeme udržiavať "stav": koľko písmen sme už videli v tomto riadku

#include <cstdio>
#include <cstring>
int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int maxDlzka = 0; // dlzka najdlhsieho riadku doteraz
    const int maxN = 100;
    char str[maxN];
    while (fgets(str, maxN, fr) != NULL) {
        int dlzka = strlen(str);
        if (dlzka > maxDlzka) {
            maxDlzka = dlzka;
        }
    }
    printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka);
    fclose(fr);
}

#include <cstdio>

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int maxDlzka = 0;   // dlzka najdlhsieho riadku doteraz
    int dlzka = 0;      // dlzka aktualneho riadku
    int c = getc(fr);
    while (c != EOF) {  // nacitavame po znaku
        dlzka++;        // zvysime dlzku riadku
        if (c == '\n') { // koniec riadku: spracujeme ho
            if (dlzka > maxDlzka) {
                maxDlzka = dlzka;
            }
            dlzka = 0; 
        }
        c = getc(fr);
    }
    if (dlzka > maxDlzka) { // nezabudneme na posledny riadok (moze chybat \n)
        maxDlzka = dlzka;
    }
    printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka);
    fclose(fr);
}

Cvičenie: čo ak chceme zistiť, koľký riadok v súbore bol ten najdlhší?

Ešte jeden príklad: máme súbor s číslami oddelenými bielymi znakmi (medzery, tabulátory, konce riadkov,...), pričom medzi dvoma číslami môže byť aj viac ako jeden oddeľovač. Chceme spočítať súčet čísel na každom riadku.

nepríjemná kombinácia rozlišovania koncov riadku od iných bielych znakov a čítania formátovaných hodnôt (čísel)
môžeme biele znaky spracovávať cez getc, potom použiť ungetc a fscanf
alebo prečítať riadok do reťazca a rozložiť na čísla

#include <cstdio>
#include <cctype>
int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int sucet = 0;
    while(!feof(fr)) {
        int c = getc(fr);
        while(c!=EOF && isspace(c)) {
            if (c == '\n') {
                printf("Sucet %d\n", sucet);
                sucet = 0;
            }
            c= getc(fr);
        }
        if(c==EOF) { break; }
        ungetc(c, fr);
        int hodnota;
        fscanf(fr, "%d", &hodnota);
        sucet += hodnota;
    }    
    fclose(fr);
}

Cvičenia:

upravte program, aby fungoval aj ak posledný riadok nie je ukončený '\n'
upravte program, aby na výstupe vypisoval aj čísla na riadkoch oddelené medzerami

Jednoduché šifrovanie

Prácu so súbormi si precvičíme na jednoduchých šifrách.

Cézarova šifra

Cézarova šifra je šifra, kde každé písmeno vstupného reťazca posunieme v abecede cyklicky o K miest.

Napr. ak K=2, tak namiesto A budeme budeme písať C, namiesto B píšeme D, namiesto Z píšeme B.
Ukážeme si použitie pre anglickú abecedu (t.j. znaky 'A'-'Z' bez diakritiky), ale je možné ju použiť napríklad aj na ASCII kódy.

void encryptCezar(FILE *fr, int K) {
    assert(0 <= K && K < 26);

    int c = getc(fr);
    while (c != EOF) {
        if ((c <= 'Z') && (c >= 'A')) {  // prekodujeme pismeno
            c = c + K;
            if (c > 'Z') {
                c = c - 26;
            }
            putc(c, stdout);
        }
        else if (isspace(c)) {  // medzery kopirujeme na vystup
            putc(c, stdout);
        }
        c = getc(fr);
    }
}

Text, ktorý chceme zašifrovať načítavame zo súboru fr a posúvame znaky 'A'-'Z' o nejakú konštantu K.
Biele znaky kopírujeme.
Zašifrovaný text vypisujeme na obrazovku, nebol pri problém to zmeniť do súboru.
Cvičenie: upravte program tak, aby správne šifroval aj malé písmená a aby na obrazovku kopíroval aj iné znaky, napr. čísla a interpunkciu.

Pri dešifrovaní postupujeme podobne, len číslo K od prečítaného znaku odrátame (pozor na prechod cez A).

Vigenerova šifra

Vigenerova šifra je veľmi podobná Cézarovej, ale posun nie je konštantný, ale podľa kľúča.

Kľúč je nejaké slovo z písmen A-Z, pričom tieto sa písmená predstavujú posuny o 0..25
Pri šifrovaní aj dešifrovaní cyklicky používame posuny z kľúča
Kľúč samozrejme musí byť známy obidvom stranám.

void encryptVigenere(FILE *fr, char kluc[]) {
    int c = getc(fr);
    int i = 0;
    while (c != EOF) {
        if ((c <= 'Z') && (c >= 'A')) {
            c = c + kluc[i] - 'A';
            if (c > 'Z') {
                c = c - 26;
            }
            putc(c, stdout);
            i++;
            if (kluc[i] == 0) i = 0;
        } else if (isspace(c)) {
            putc(c, stdout);
        }
        c = getc(fr);
    }
}

Rastúce pole

Vráťme sa k programu, ktorý má zo súboru načítať postupnosť čísel a uložiť ich do poľa na ďalšie spracovanie

Ak je na za začiatku súboru počet čísel N, môžeme alokovať akurátne veľké pole
Ak ale počet čísel nie je vopred známy, môžeme pole nafukovať podľa veľkosti
- Začneme s malým poľom (veľkosti 2)
- Vždy keď sa pole zaplní, alokujeme nové pole dvojnásobnej veľkosti, prvky do neho skopírujeme a staré pole odalokujeme
- Presúvanie prvkov dlho trvá, preto pole vždy zdvojnásobíme, aby sme nemuseli presúvať často
- Spolu pri načítaní n prvkov robíme najviac 2n presunov jednotlivých prvkov

#include <cstdio>

int *nacitajDoPola(FILE *f, int &n) {
    /* Cita cele cisla zo suboru f az kym nepride na koniec. 
     * Uklada ich do dynamicky alokovaneho pola, ktore vrati, 
     * pocet nacitanych cisel ulozi do n */
    
    int velkost = 2;                // zacneme s polom s 2 prvkami
    int *pole = new int[velkost];
    n = 0;                           // 0 cisel je zatial ulozenych
    while (!feof(f)) {
        if (n == velkost) {          // ak sme naplnili pole, presunime do vacsieho
            velkost *= 2;
            int *nove = new int[velkost];
            /* prekopirujeme zo stareho do noveho */
            for (int i = 0; i < n; i++) {
                nove[i] = pole[i];
            }
            /* zmazeme stare */
            delete[] pole;
            pole = nove;
        }

        fscanf(f, "%d ", &pole[n]);  // v poli je miesto, ulozime novu hodnotu
        n++;
    }
    return pole;
}

int main(void) {
    int n;
    int *a;
    a = nacitajDoPola(stdin, n);   // nacitame pole a a pocet n
    for (int i = 0; i < n; i++) {  // spracovavame, ako sme zvyknuti
        printf(" %d", a[i]);
    }
    printf("\n");
    delete[] a;                    // nakoniec zmazeme pole a
}

Vector

Rastúce pole z predchádzajúceho programu by sa nám mohlo zísť aj na iné účely

V C++ knižniciach je štruktúra <a href="http://www.cplusplus.com/reference/vector/vector/">vector</a>, ktorá podobne rastie podľa potreby
My si jednoduchšiu verziu vektora naprogramujeme.
Na začiatku programu si zadefinujeme, akého typu prvky budeme do vektora dávať (napr. int, doble, char a pod.)

typedef int dataType;

Náš vektor bude struct s potrebnými údajmi a bude poskytovať nasledujúce funkcie
- void init(vector &a) vytvorí prázdny vektor
- void add(vector &a, dataType x) pridá na koniec vektoru prvok x
- dataType get(vector &a, int i) vráti prvok na pozícii i v poli, pričom kontroluje, či je index platný (od 0 po najväčší vložený prvok) a ak nie, ukončí program príkazom assert
- void set(vector &a, int i, dataType x) na pozíciu i v poli uloží prvok x (s kontrolou indexu i)
- int length(vector &a)
- void destroy(vector &a) zmaže pamäť alokovanú pre vektor a
Štruktúra vector teda v sebe združuje pole aj jeho dĺžku, stačí posielať jeden parameter
Vector posielame do funkcií referenciou, aby sa zbytočne veľa nekopírovalo (a tiež aby sme ho mohli v prípade potreby meniť)
Vector by sme teraz vedeli použiť bez toho, aby sme vedeli, ako sú funkcie naprogramované vo vnútri
- Môžeme teda implementáciu vectora meniť bez zmeny programu, ktorý ho používa

typedef double dataType;
// sem pride definicia tyzpu vector + funkcie uvedene vyssie

int main(void) {
    vector a;
    init(a);    
    add(a, 0.5);    // mame 1-prvkove pole {0.5}
    add(a, 1.0);    // mame 2-prvkove pole {0.5, 1.0}
    set(a, 1, 1.5); // mame 2-prvkove pole {0.5, 1.5}
    printf("%f\n", get(a,0) + get(a,1));  // vypise 2.0000
    destroy(a);
}

V objektovo-orientovanom programovaní (budúci semester) sa namiesto napr. get(a,0) píše niečo ako a.get(0)

Implementácia vectora

struct vector {
    dataType *a; /* pole prvkov typu dataType */
    int size; /* velkost alokovaneho pola */
    int n; /* pocet prvkov pridanych do pola */
};

void init(vector &a) {
    /* inicializuj vektor s kratkym polom */
    a.size = 2;
    a.a = new dataType[a.size];
    a.n = 0;
}

void add(vector &a, dataType x) {
    /* na koniec pola pridaj prvok x, zvacsi pole ak treba */

    if (a.n == a.size) {
        /* treba zvacsovat */
        dataType *nove = new dataType[a.size * 2];
        /* prekopirujeme zo stareho do noveho */
        for (int i = 0; i < a.n; i++) {
            nove[i] = a.a[i];
        }
        /* zmazeme stare */
        delete [] a.a;
        /* upravujeme premenne */
        a.a = nove;
        a.size *= 2;
    }
    /* teraz uz je pole dost velke, staci ulozit x */
    a.a[a.n] = x;
    a.n++;
}

dataType get(vector &a, int i) {
    /* vrat prvok v poli na pozicii i (s kontrolou i) */
    assert(i >= 0 && i < a.n);
    return a.a[i];
}

void set(vector &a, int i, dataType x) {
    /* na poziciu i uloz hodnotu x (s kontrolou i) */
    assert(i >= 0 && i < a.n);
    a.a[i] = x;
}

void destroy(vector &a) {
    delete[] a.a;
}

int length(vector &a) {
    return a.n;
}

Použitie vektora pri načítaní dát

Vráťme sa k príkladu, kde sme načítavali desatinné čísla zo súboru až do konca súboru
Vtedy sme priamo pri načítaní čísel menili veľkosť poľa
Teraz vieme zapísať pomocou operácie add, oddelili sme prácu s alokovaním poľa a prácu so súborom

int main(void) {
    FILE *fr = fopen("vstup.txt", "r"); // otvorime vstupny subor

    vector a;                           // vytvorime a inicializujeme vektor a
    init(a);
    
    while (!feof(fr)) {                // nacitavame prvky do vektora 
        double hodnota;
        fscanf(fr, "%lf ", &hodnota); 
        add(a, hodnota);
    }
    fclose(fr); // zavrieme vstupny subor

    double sucet = 0;                       // teraz pracujeme s a, napr. spocitame sucet prvkov vo vektore
    for (int i = 0; i < length(a); i++) {
        sucet += get(a, i);
    }

    printf("pocet: %d, sucet: %f\n", length(a), sucet); // vypise pocet prvkov a ich sucet na konzolu
    destroy(a);                            // uvolnime pamat vektora a
}

Prednáška 15

Opakovanie smerníkov

Smerníky na jednoduché premenné:

int a = 7;         /* premenna typu int */
int *b = NULL;     /* smernik na premennu typu int */
b = &a;            /* b ukazuje na a */
*b = 8;            /* v premennej a je teraz 8 */
a = (*b)+1;        /* v premennej a je teraz 9 */

Smerníky na structy:

struct bod {
  int x,y;
};
bod *p;       /* smernik na structuru typu bod */
p = new bod;  /* alokovanie noveho bodu */
p->x = 10;    /* dve formy priradovania do sucasti structu */
(*p).y = 20;
delete p;     /* uvoľníme alokovanú pamäť */

Smerníky a polia, alokovanie poľa:

int a[3];
int *b = a;  /* a,b su teraz takmer rovnocenne premenne */
*b = 3;
b[1] = 4;
a[2] = 5; /* v poli sú teraz čísla 3,4,5 */
b = new int[a[1]];  /* b teraz ukazuje na nove pole dlzky 4 */
delete[] b;         /* uvoľníme pamäť alokovanú pre nové pole */

Smerníková aritmetika

Pole je vlastne smerník na svoj prvý prvok
Majme napr. pole int a[4] = {4, 3, 2, 1};
K i-temu prvku sa vieme dostať pomocou a[i]
Dá sa to však napísať aj ako *(a+i)
Konkrétne a+i je smerník na i-ty prvok poľa a
Kompilátor spočíta veľkosť jedného políčka poľa, takže vie, ako ďaleko sa posunúť, aby sa dostal na i-te políčko
int *b = a+2 vytvorí smerník na a[2], ale k b sa môžeme správať ako ku dvojprvkovému poľu {2, 1}

Smerníková aritmetika:

smerník + n: Posun smerníka o n. Ak napríklad smerník ukazuje na 0. prvok poľa, smerník + n bude ukazovať na n-tý prvok poľa.
- Ak chceme zvýšiť smerník o 1 môžeme použiť smerník++.
smerník - n: Posun smerníka o n prvkov smerom k začiatku.
smerník1 - smerník2: Výsledkom rozdielu smerníkov je vzdialenosť miest na ktoré ukazujú. Ak napríklad prvý smerník ukazuje na 5. prvok poľa a druhý smerník na 3. prvok poľa ich rozdiel je 2. Smerníky musia patriť do toho istého poľa, inak bude výsledok nedefinovaný.

Porovnávanie ukazovateľov:

operátory: < <= > >= == !=
porovnávanie má zmysel len keď ukazovatele:
- sú rovnakého typu
- ukazujú do toho istého poľa

Tu je napr. zvláštny spôsob ako vypísať pole a definované vyššie:

for (int *smernik = a; smernik < a + 4; smernik++) {
     cout << "Prvok " << smernik - a << " je " << *smernik << endl;
}

Podobný kód sa ale občas používa na prechádzanie reťazcov, napr. ak chceme zrátať počet medzier v reťazci:

int zratajMedzery(char str[]) { // mohli by sme dat aj char *str
  int pocet = 0;
  while(*str != 0) {   // kym nenajdeme ukoncovaciu nulu v retazci
     if(*str==' ') { pocet++; }  // skontroluj znak, na ktory ukazuje smernik
     str++;                      // posun smernik na dalsi znak 
  }
  return pocet;
}

Funkcie z knižnice cstring s reťazcovou aritmetikou

strstr(text, vzorka) vracia smerník na char
- NULL ak sa vzorka nenachádza v texte, smerník na začiatok prvého výskytu inak
- pozíciu výskytu zistíme smerníkovou aritmetikou:

char *text, *vzorka;
char *where = strstr(text, vzorka);
if(where != NULL) {
  int position = where - text;
}

Ako by ste spočítali počet výskytov vzorky v texte?
Podobne strchr hľadá prvý výskyt znaku v texte

Sizeof()

Operátor sizeof() zistí "veľkosť" dátového typu v bajtoch

napr. pri struct sa nemusí jednať o súčet veľkostí
presnejšie ide o vzdialenosť medzi nasledujúcimi prvkami poľa -- teda o koľko sa posunieme pri posune +1 v smerníkovej aritmetike

int i, *pi;
sizeof(*pi);   //počet bajtov potrebných na uloženie typu int 
sizeof(i);     // da sa napisat aj takto
sizeof(int);   // alebo takto

sizeof(pi);    // pocet bajtov na ulozenie smernika na int
sizeof(int *); // to iste

Dvojrozmerné polia

Doteraz sme stále pracovali s jednorozmerným poľom, čo však ak potrebujeme dvojrozmerné pole, maticu?
Spravme teraz maticu s n=10 riadkami a m=20 stĺpcami
Spravíme si pole n jednorozmerných polí, t.j. pole smerníkov na int: int *a[n];
Naalokujeme si n jednorozmerných polí veľkosti m a smerník na každé uložíme do jedného prvku poľa a

const int n = 10;
const int m = 20;
int *a[n];
for (int i = 0; i < n; i++) {
    a[i] = new int[m];
}

Prvok v i-tom riadku a j-tom stĺpci dostaneme jedným z týchto spôsobov:

a[i][j]
*(*(a+i)+j)

Tu je kód, ktorý vynuluje pole:

for (int i = 0; i < n; i++) {
   for (int j = 0; j < m; j++) {
       a[i][j] = 0;
   }
}

Na konci sa patrí pamäť uvoľniť:

for (int i = 0; i < n; i++) {
    delete[] a[i];
}

Dynamicky alokovaná matica

Ak chceme n a m určiť dynamicky, napr. načítať ich zo súboru, musíme aj pole a alokovať pomocou new a nakoniec uvoľniť pomocou delete[]:

#include <cstdio>
using namespace std;

int main(void) {
    int n, m;
    scanf("%d %d,&n,&m);  // nacitame n a m
    int **a;              // alokujeme maticu nxm
    a = new int *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }

    for (int i = 0; i < n; i++) {  // pracujeme s maticou, napr. vynulujeme ju
        for (int j = 0; j < m; j++) {
            a[i][j] = 0;
        }
    }

    for (int i = 0; i < n; i++) {  // na konci uvolnime pamat
        delete[] a[i];
    }
    delete[] a;
}

Funkcie pre alokáciu matice

Na alokáciu a dealokáciu matice si napíšeme funkcie, môžu sa nám hodiť:

int ** vytvorMaticu(int n, int m) {
    /* vytvor maticu s n riadkami a m stlpcami */
    int **a;
    a = new int *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }
    return a;
}

void zmazMaticu(int n, int m, int **a) {
    /* uvolni pamat matice s n riadkami a m stlpcami */
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
}

void nacitajMaticu(FILE *f, int n, int m, int **a) {
    /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            fscanf(f, "%d", &a[i][j]);
        }
    }
}

Všimnite si, že všetkým funkciám dávame aj rozmery matice. Namiesto toho by sme si mohli spraviť štruktúru podobne ako pri vektore:

struct matica {
  int n, m;
  int **a;
}

Výšková mapa

V matici môžeme mať danú napr. mapu:

0 znamené more
kladné číslo znamená pevninu a udáva nadmorskú výšku (napr. v metroch)

Táto reprezentácia neumožňuje zapísať pevninu pod úrovňou mora.

Pomocou funkcií vyššie môžeme takúto mapu načítať zo súboru a môžeme spraviť napr. program, ktorý zobrazí more modrou a pevninou odtieňami zelenej a hnedej podľa nadmorskej výšky. Príklad matice a obrázku:

22 11
 0 0 0 0 0 0 0 0 0 0 0
 0 20 40 60 80 100 120 140 120 0 0
 0 40 80 120 160 200 240 280 190 100 0
 0 60 120 180 240 300 360 420 260 100 0
 0 80 160 240 320 400 480 560 260 100 0
 0 100 200 300 400 500 600 700 330 100 0
 0 120 240 360 480 600 720 840 400 100 0
 0 140 280 420 560 700 840 980 470 100 0
 0 160 320 480 640 800 960 700 200 0 0
 0 180 360 540 720 900 700 500 0 0 0
 0 200 400 600 800 1000 1200 1400 680 100 0
 0 220 440 660 880 1100 1320 1540 750 100 0
 0 240 480 720 960 1200 1440 1680 820 100 0
 0 260 520 780 1040 1300 1560 1820 1200 400 0
 0 280 560 840 1120 1400 1680 1960 1500 600 0
 0 240 480 720 960 1200 1440 1680 1000 400 0
 0 200 400 600 800 1000 1200 1400 680 100 0
 0 160 320 480 640 800 960 1120 540 100 0
 0 120 240 360 480 600 720 840 400 100 0
 0 80 160 240 320 400 480 560 260 100 0
 0 40 80 120 160 200 240 280 120 0 0
 0 0 0 0 0 0 0 0 0 0 0

Okrem zobrazovania môžeme chcieť napríklad nájsť polohu najvyššieho vrchu a zobraziť ho v čiernom rámčeku, ako na obrázku vyššie.

Čo spraví funkcia, ak je celá mapa pokrytá morom?

void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) {
    /* najdi polohu najvyssej hodnoty v matici */
    riadok = 0;
    stlpec = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if(a[i][j]>a[riadok][stlpec]) {
                riadok = i;
                stlpec = j;
            }
        }
    }
}

Príklad hlavného programu, ktorý hľadá najvyšší vrch.

int main(void) {
    /* nacitaj rozmery matice */
    int n, m;
    scanf("%d %d", &n, &m);

    /* vytvor a nacitaj maticu */
    int **a = vytvorMaticu(n, m);
    nacitajMaticu(stdin, n, m, a);

    /* najdi najvyssi vrch */
    int riadok, stlpec;
    najvyssiVrch(n, m, a, riadok, stlpec);

    /* uvolni pamat matice */
    zmazMaticu(n, m, a);
}

Zdrojový kód celého programu

Tento program načíta maticu, nájde najvyšší vrch a vykreslí obrázok: #Program mapa pre prednášku 15

Hra life

Hra life je jednoduchá simulácia kolónie buniek, ktorá má zaujímavé teoretické vlastnosti.

Máme mriežku m x n štvorčekov, v každom žije najviac 1 bunka
Bunky sa rodia a umierajú podľa toho, koľko majú susedov v ôsmych okolitých políčkach
- Ak v čase t má bunka 2 alebo 3 susedov, zostane žiť aj v čase t+1, inak zomiera
- Ak v čase t má prázden políčko presne 3 susedov, narodí sa tam v čase t+1 nová bunka

Stav hry si môžeme pamätať v matici boolovských hodnôt.

Rátanie zmeny v matici

Stav v čase t máme v matici a, do matice b chceme dať stav v čase t+1

int zratajOkolie(int n, int m, bool **a, int riadok, int stlpec) {
    /* pocet zivych prvkov v okoli */
    int sucet = 0;
    for (int i = riadok - 1; i <= riadok + 1; i++) {
        for (int j = stlpec - 1; j <= stlpec + 1; j++) {
            /* treba osetrit okraje matice */
            if (i >= 0 && i < n && j >= 0 && j < m && a[i][j]) {
                sucet++;
            }
        }
    }
    /* samotny stvorcek nechceme zaratat */
    if (a[riadok][stlpec]) {
        sucet--;
    }
    return sucet;
}

void prepocitajMaticu(int n, int m, bool **a, bool **b) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int pocet = zratajOkolie(n, m, a, i, j);
            /* prirad do b[i][j] hodnotu podla okolia a[i][j] */
            b[i][j] = (pocet == 3 || (pocet == 2 && a[i][j]));
        }
    }
}

Hlavný program

Prepočítavanie chceme opakovať v cykle pre viacero časových intervalov
Môžeme prekopírovať celú maticu z b späť do a, ale rýchlejšie je len vymeniť smerníky

    for (int i = 0; i < 10; i++) {
        /* podla a spocitaj maticu do b */
        prepocitajMaticu(n, m, a, b);
        /* vymen smerniky, aby v a bola nova matica */
        bool **tmp = b;
        b = a;
        a = tmp;
    }

vytvorMaticu, zmazMaticu a pod. prepíšeme tak, aby robili s maticou boolovských hodnôt namiesto intov

int main(void) {
    /* nacitaj rozmery matice */
    int n, m;
    scanf("%d %d", &n, &m);

    /* vytvor a nacitaj maticu */
    bool **a = vytvorMaticu(n, m);
    nacitajMaticu(stdin, n, m, a);

    /* zobraz maticu */
    SVGdraw drawing(m*stvorcek, n * stvorcek,"life.svg");
    zobrazMaticu(n, m, a, drawing);
    drawing.wait(1);

    /* pomocna matica na vypocty */
    bool **b = vytvorMaticu(n, m);

    /* simuluj 10 krokov hry life */
    for (int i = 0; i < 10; i++) {
        /* podla a spocitaj maticu do b */
        prepocitajMaticu(n, m, a, b);
        /* prekresli, co sa zmenilo */
        zobrazZmeny(n, m, a, b, drawing);
        drawing.wait(1);
        /* vymen smerniky, aby v a bola nova matica */
        bool **tmp = b;
        b = a;
        a = tmp;
    }

    /* uvolni pamat matic */
    zmazMaticu(n, m, a);
    zmazMaticu(n, m, b);
    drawing.finish();
}

Detaily vykresľovania

Na začiatku vykreslíme celú maticu, potom prekreslíme vždy len tie bunky, ktoré sa zmenili

void zobrazStvorcek(int i, int j, bool hodnota, SVGdraw &drawing) {
    /* zobraz stvorcek v riadku i a stlpci j */
    drawing.setLineColor("white");
    if (hodnota) {
        drawing.setFillColor("black");
    } else {
        drawing.setFillColor("white");
    }
    drawing.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek);
}

void zobrazMaticu(int n, int m, bool **a, SVGdraw &drawing) {
    /* zobraz prvky true ciernymi stvorcekmi */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            /* nastavenie farby podla hodnoty */
            if (a[i][j]) {
                zobrazStvorcek(i, j, true, drawing);
            }
        }
    }
}

void zobrazZmeny(int n, int m, bool **a, bool **b, SVGdraw &drawing) {
    /* zobraz nove stvorceky na miestach, kde bola zmena */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (a[i][j] != b[i][j]) zobrazStvorcek(i, j, b[i][j], drawing);
        }
    }
}

Príklad vstupu

Pre jednoduchosť vstup uvádzame ako nuly a jednotky bez medzier (1=živá bunka)

20 20
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000111111111100000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000

Zdrojový kód celého programu

Tento program načíta vstup a simuluje 10 krokov hry Life: #Program life pre prednášku 15

Pole reťazcov

Dvojrozmerné polia v C/C++ nemusia mať všetky riadky rovnako dlhé.

Spomeňte si, že v C je reťazec jednoducho pole char-ov, kde za posledným znakom ide špeciálny znak 0
Pole reťazcov bude teda dvojrozmerné pole char-ov
Môžeme načítavať napr. súbor po riadkoch, pričom každý riadok načítame do dlhého poľa, ktoré by malo stačiť a potom do prekopírujeme do akurát veľkého riadku v poli
Nakoniec program riadky vypíše odzadu
Ak by sme vopred alokovali maxN riadkov, každý veľkosti maxRiadok, vyšlo by potenciálne na zmar oveľa viac pamäte.

#include <cstdio>
#include <string.h>
using namespace std;

const int maxRiadok = 1000;
const int maxN = 1000;

int main(void) {
    char *a[maxN];
    char riadok[maxRiadok];
    int n = 0;
    while (true) {
        if (!fgets(riadok, maxRiadok,stdin)) break;
        a[n] = new char[strlen(riadok)+1];
        strcpy(a[n], riadok);
        n++;
        if (feof(stdin)) break;
    }

    for(int i=n-1; i>=0; i--) {
        printf("%s", a[i]);
    }
}

Program mapa pre prednášku 15

/* Program Mapa z prednášky 15. 
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */

#include "../SVGdraw.h"
#include <cstdio>

/* velkost stvorceka mapy v pixeloch */
const int stvorcek = 15;

int ** vytvorMaticu(int n, int m) {
    /* vytvor maticu s n riadkami a m stlpcami */
    int **a;
    a = new int *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }
    return a;
}

void zmazMaticu(int n, int m, int **a) {
    /* uvolni pamat matice s n riadkami a m stlpcami */
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
}

void nacitajMaticu(FILE *f, int n, int m, int **a) {
    /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            fscanf(f, "%d", &a[i][j]);
        }
    }
}

void farba(SVGdraw &drawing, int r, int g, int b) {
    /* nastav farbu ciary aj vyplne na dane hodnoty */
    drawing.setLineColor(r, g, b);
    drawing.setFillColor(r, g, b);
}

void zobrazMaticu(int n, int m, int **a, SVGdraw &drawing) {
    /* zobraz maticu farebnymi stvorcekmi :
     * modra: more (hodnota 0)
     * zelena: niziny 1..200,
     * hneda: pohoria 200..2000 */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            /* nastavenie farby podla hodnoty */
            if (a[i][j] == 0) {
                farba(drawing, 0, 0, 255);
            } else if (a[i][j] <= 200) {
                double x = a[i][j] / 200.0;
                farba(drawing, x * 255, 127 + x * 127, 0);
            } else {
                double x = (a[i][j] - 200) / 2000.0;
                farba(drawing, 255 - x * 150, 255 - x * 200, 0);
            }
            /* vykresleni stvorceka, pozor: vymena suradnic */
            drawing.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek);
        }
    }
}

void najvyssiVrch(int n, int m, int **a, int &riadok, int &stlpec) {
    /* najdi polohu najvyssej hodnoty v matici */
    riadok = 0;
    stlpec = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if(a[i][j]>a[riadok][stlpec]) {
                riadok = i;
                stlpec = j;
            }
        }
    }
}

int main(void) {
    /* nacitaj rozmery matice */
    int n, m;
    scanf("%d %d", &n, &m); //22 11

    /* vytvor a nacitaj maticu */
    int **a = vytvorMaticu(n, m);
    
    nacitajMaticu(stdin, n, m, a);
    
    /* zobraz maticu */
    SVGdraw drawing(m*stvorcek, n * stvorcek, "mapa.svg");
    zobrazMaticu(n, m, a, drawing);

    /* najdi najvyssi vrch a zobraz ho stvorcekom */
    int riadok, stlpec;
    najvyssiVrch(n, m, a, riadok, stlpec);
    
    drawing.setLineColor("black");
    drawing.setNoFill();
    drawing.drawRectangle(stlpec*stvorcek, riadok*stvorcek, stvorcek, stvorcek);

    /* zobraz okno */
    drawing.finish();

    /* uvolni pamat matice */
    zmazMaticu(n, m, a);
}

Program life pre prednášku 15

/* Program Hra Life z prednášky 15. 
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_15 */
 
#include "../SVGdraw.h"
#include <cstring>
#include<cstdio>
#include <cassert>
using namespace std;

/* velkost stvorceka */
const int stvorcek = 15;

bool ** vytvorMaticu(int n, int m) {
    /* vytvor maticu s n riadkami a m stlpcami */
    bool **a;
    a = new bool *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new bool[m];
    }
    return a;
}

void zmazMaticu(int n, int m, bool **a) {
    /* uvolni pamat matice s n riadkami a m stlpcami */
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
}

void nacitajMaticu(FILE *f, int n, int m, bool **a) {
    /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */
    for (int i = 0; i < n; i++) {
        char riadok[100];
        fscanf(f,"%s",riadok);
        assert(strlen(riadok) == m);
        for (int j = 0; j < m; j++) {
            a[i][j] = (riadok[j] == '1');
        }
    }
}

void zobrazStvorcek(int i, int j, bool hodnota, SVGdraw &drawing) {
    /* zobraz stvorcek v riadku i a stlpci j */
    drawing.setLineColor("white");
    if (hodnota) {
        drawing.setFillColor("black");
    } else {
        drawing.setFillColor("white");
    }
    drawing.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek);
}

void zobrazMaticu(int n, int m, bool **a, SVGdraw &drawing) {
    /* zobraz prvky true ciernymi stvorcekmi */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            /* nastavenie farby podla hodnoty */
            if (a[i][j]) {
                zobrazStvorcek(i, j, true, drawing);
            }
        }
    }
}

void zobrazZmeny(int n, int m, bool **a, bool **b, SVGdraw &drawing) {
    /* zobraz nove stvorceky na miestach, kde bola zmena */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (a[i][j] != b[i][j]) zobrazStvorcek(i, j, b[i][j], drawing);
        }
    }
}
int zratajOkolie(int n, int m, bool **a, int riadok, int stlpec) {
    /* pocet zivych prvkov v okoli */
    int sucet = 0;
    for (int i = riadok - 1; i <= riadok + 1; i++) {
        for (int j = stlpec - 1; j <= stlpec + 1; j++) {
            /* treba osetrit okraje matice */
            if (i >= 0 && i < n && j >= 0 && j < m && a[i][j]) {
                sucet++;
            }
        }
    }
    /* samotny stvorcek nechceme zaratat */
    if (a[riadok][stlpec]) {
        sucet--;
    }
    return sucet;
}

void prepocitajMaticu(int n, int m, bool **a, bool **b) {
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            int pocet = zratajOkolie(n, m, a, i, j);
            /* prirad do b[i][j] hodnotu podla okolia a[i][j] */
            b[i][j] = (pocet == 3 || (pocet == 2 && a[i][j]));
        }
    }
}

int main(void) {
    /* nacitaj rozmery matice */
    int n, m;
    scanf("%d %d", &n, &m);//20 20

    /* vytvor a nacitaj maticu */
    bool **a = vytvorMaticu(n, m);
    nacitajMaticu(stdin, n, m, a);

    /* zobraz maticu */
    SVGdraw drawing(m*stvorcek, n * stvorcek,"life.svg");
    zobrazMaticu(n, m, a, drawing);
    drawing.wait(1);

    /* pomocna matica na vypocty */
    bool **b = vytvorMaticu(n, m);

    /* simuluj 10 krokov hry life */
    for (int i = 0; i < 10; i++) {
        /* podla a spocitaj maticu do b */
        prepocitajMaticu(n, m, a, b);
        /* prekresli, co sa zmenilo */
        zobrazZmeny(n, m, a, b, drawing);
        drawing.wait(1);
        /* vymen smerniky, aby v a bola nova matica */
        bool **tmp = b;
        b = a;
        a = tmp;
    }

    /* uvolni pamat matic */
    zmazMaticu(n, m, a);
    zmazMaticu(n, m, b);
    drawing.finish();
}

Cvičenia 8

Vstup

Napíšte program, ktorý vypíše súbor vstup.txt na obrazovku tak, že všetky riadky dlhšie ako 80 znakov ureže na 80-tom stĺpci.
- Váš program by mal fungovať aj pre súbory s veľmi dlhými riadkami
Napíšte program, ktorý od užívateľa načíta názvy dvoch súborov a potom zistí, či tieto dva súbory majú rovnaký obsah.
V súbore máme na každom riadku tri údaje oddelené medzerami: desatinné číslo, znamienko (jedno z +, -, *, /) a druhé desatinné číslo. Postupne načítavajte tento súbor a na konzolu vypisujte výrazy aj s výslednou hodnotu. Na vypisovanie čísel typu double skúste použiť formát %g v príkaze printf. Príklad:

Vstup:

1.5 + 3
-7 - -8.1
3 / 2

Výstup:

1.5 + 3 = 4.5
-7 - -8.1 = 1.1
3 / 2 = 1.5

Výstup

Do súboru vypíšte tabuľku hodnôt funkcie sin(x) pre x od -1 po 1 s krokom 0.2, pričom ich bude vypisovať na 5 desatinných miest a x aj sin(x) budú zarovnané doprava:

-1.0 -0.84147
-0.8 -0.71736
-0.6 -0.56464
-0.4 -0.38942
-0.2 -0.19867
-0.0 -0.00000
 0.2  0.19867
 0.4  0.38942
 0.6  0.56464
 0.8  0.71736
 1.0  0.84147

Štatistika

Stiahnite si textový súbor [2], ktorý obsahuje frekvenciu, s akou užívatelia vyhľadávali výraz ice cream v Googli v jednotlivých týždňoch rokov 2004 až 2010. Každý riadok obsahuje údaje o jednom týždni: prvé tri slová sú dátum, štvrté relatívna frekvencia.
Načítajte tento súbor do poľa záznamov so štruktúrou

struct tyzden {
  char[4] mesiac;
  int den;
  int rok;
  double frekvencia;
};

Vypíšte na konzolu, v ktorom týždni bola frekvencia vyhľadávania najvyššia.
Pre každý rok od 2004 po 2010 spočítajte súčet frekvencií a vypíšte na konzolu v prehľadnom tvare, na dve desatinné miesta:

Šifrovanie permutačnou šifrou

Napíšte funkciu, ktorá zašifruje vstupný súbor tak, že v každom bloku dĺžky n povymieňa polohu znakov podľa zadaného kľúča. Kľúč je pole A dĺžky n, kde A[i] uvádza, ktoré písmeno z pôvodného bloku má ísť na i-te miesto v zašifrovanom bloku. Napr. pre n=4 a A={3,2,0,1} dostaneme pre blok "ABCD" výsledok "DCAB", lebo na pozíciu 0 vo výsledku sme dali písmeno na pozícii A[0] = 3, t.j. D, atď. Ak v poslednom bloku nemáme dosť písmen, doplníme ich medzerami. Hlavička funkcie: void encryptPermutation(FILE *f, int n, int A[]);

Pre dešifrovanie môžeme použiť tú istú funkciu, akurát kľúč musíme zmeniť z pôvodnej permutácie A na novú permutáciu B tak, že B[A[i]]=i pre každé i. Napr. pre príklad vyššie to bude B={2,3,1,0}

Vyskúšajte touto šifrou zašifrovať a potom spätne odšifrovať krátky text.

Prednáška 16

Dynamická alokácia poľa a matice, opakovanie

1D pole: int *a = new int[n]; cin >> a[0];
2D pole: int **a = new int * [n]; for(int i=0; i<n; i++) a[i] = new int[m]; cin >> a[0][1];
- Riadky 2D poľa nemusia byť rovnako dlhé
3D pole: int ***a = new int ** [n]; ...

Vstupy do funkcie main

Netbeans vám vyrobí main funkciu s nasledujúcou hlavičkou:

int main(int argc, char** argv) {

char **argv je pole C-čkových reťazcov a argc je počet reťazcov v tomto poli
Prvý z nich, argv[0], je meno samotného programu a ostatné sú argumenty programu
Užitočné, ak spúšťame program z príkazového riadku
Dá sa nastaviť v Netbeans, Properties, Run
Tento program jednoducho argumenty vypíše

#include <iostream>
using namespace std;

int main(int argc, char** argv) {
    for (int i = 0; i < argc; i++) {
        cout << argv[i] << endl;
    }
}

Smerníkové kuriozity

    int *a[3];                /* pole 3 smerníkov na int */
    int (*b)[3];              /* jeden smerník na pole troch intov, neinicializovaný */
    int c[3] = {0,1,2};       /* pole troch intov */
    b = &c;                   /* teraz b ukazuje na pole c */
    cout << (*b)[2] << endl;  /* pristup k prvku 2 pola c */
    cout << *b[2] << endl;    /* zle: tvarime sa, ze b je pole, pristupime k jeho prvku 2 a interpretujeme ho ako smernik */

Spájaný zoznam

Ak niekde chceme uložiť N prvkov, doteraz sme videli nasledujúce možnosti:

Vytvoriť pole pevnej veľkosti N, ak je N vopred známa konštanta: const int N = 100; int A[N];
Vytvoriť veľké pole, ktoré dúfame bude stačiť, časť z neho môže nepoužitá: const int maxN = 100; int A[maxN];
Dynamicky alokovať pole N prvkov, ak N je číslo spočítané niekde v programe alebo načítané zo súboru: int *A = new int[N];
Pomocou new vieme naprogramovať aj štruktúru vector, do ktorej môžeme postupne pridávať prvky, aj keď vopred nevieme N

Teraz si ukážeme ďalší spôsob, ako si prvky ukladať, keď vopred nevieme ich počet

Štruktúra jednoduchého spájaného zoznamu

Spájaný zoznam (linked list) je postupnosť uzlov rovnakého typu usporiadaných za sebou.

Každý uzol pozostáva z dvoch častí:

smerník, ktorý ukazuje na nasledovníka a pomáha nám sa pohybovať po zozname
samotné dáta, v našom prípade pre jednoduchosť int

Uzol spájaného zoznamu je teda pre naše účely nasledovného typu:

struct node {
    int data;
    node* next;
};

Všimnite si, že vo vnútri definície typu node používame smerník na node.

Na rozdiel od poľa, v ktorom je poradie stanovené indexmi, je teda poradie v spájanom zozname určované ukazovateľmi next. Ak x je prvok zoznamu, tak x.next je

nasledujúci prvok zoznamu
NULL (ak x je posledným prvkom zoznamu)

Samotný typ linkedList reprezentujúci celý zoznam si potrebuje pamätať smerník na úvodný prvok:

struct linkedList {
    node* first;
};

Pre prázdny zoznam z bude z.first rovné NULL.

Inicializácia zoznamu je teda veľmi jednoduchá:

void init(linkedList &z){
    z.first = NULL;
}

int main(void){
    linkedList z;
    init(z); 
}

Tiež vieme veľmi jednoducho určiť, či je zoznam prázdny:

bool empty(const linkedList &z){
    if (!z.first) return true; // resp. (z.first == NULL) 
    else return false;
}

Vkladanie a vymazanie na začiatku

Na to, aby sme zoznam nejakým spôsobom naplnili, potrebujeme vedieť vytvoriť prvok zoznamu. To robíme dynamicky nasledovne:

node* p = new node;
p->data = NEJAKE_DATA;
p->next = NEJAKY_SMERNIK_NIEKAM;

Teda vytvoríme si smerník na uzol zoznamu, vyhradíme mu patričný kus pamäte a naplníme ho vhodnými dátami.

Môžeme si teda skúsiť vytvoriť zoznam z, ktorý bude mať 3 prvky 1,2 a 3.

linkedList z;
node* p = new node;
node* q = new node;
node* r = new node;
p->data = 1; 
q->data = 2; 
r->data = 3;
p->next = q;
q->next = r;
r->next = NULL;
z.first = p;

Pravdepodobne nechceme vytvárať zoznam ako v príklade a potrebujeme teda funkciu na vloženie prvku. Najjednoduchšia možnosť je vkladanie na začiatok zoznamu. Samozrejme prvku budeme musieť vhodne nastaviť jeho smerník next a asi aj nejaké smerníky v zozname.

void insertFirst(linkedList &z, int d){
    /* do zoznamu z vlozi na zaciatok novy prvok s datami d */
    node* p = new node;   // vytvoríme nový prvok
    p->data = d;          // naplníme dáta
    p->next = z.first;    // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok)
    z.first = p;          // tento prvok je novým začiatkom
}

Pre vymazanie prvého prvku postupujeme podobne, len nesmieme zabudnúť okrem presmerovania začiatku aj uvoľniť pamäť pôvodne prvého prvku. Funkcia deleteFirst vráti hodnotu prvého prvku a tento prvok vymaže.

int deleteFirst(linkedList &z){
     /* zo zoznamu z vymaze prvy prvok a vrati jeho data */
     assert(z.first != NULL);      // nemozeme mazat, ak je zoznam prazdny
 
     node* p = z.first;           // prvok, ktorý ideme vymazat
     int d = z.first->data;       // to čo máme vrátiť
     z.first = z.first->next;     // presmerujeme zoznam na novy zaciatok
     delete p;                    // uvoľnenie pamäte
     return d;
}

Prechádzanie zoznamu

Veľmi dôležité je vedieť zoznamom prechádzať a postupne pracovať s jeho prvkami. Prechádzanie zoznamom je potrebné napríklad pre hľadanie konkrétneho prvku, hľadanie najväčšieho prvku, vypisovanie všetkých prvkov zoznamu atď.

Ako budeme postupovať?

Vytvoríme si smerník na prvky zoznamu x.
Začneme prvým prvkom zoznamu. Na ten nám ukazuje smerník z.first.
Kým x nebude na konci zoznamu (t.j. nebude NULL), vypíšeme patričné dáta (x->data) a presunieme sa na ďalší prvok (x->next)
Vo chvíli, keď x je NULL, ďalší prvok už nie je (a je jedno, či sa to stalo hneď na začiatku - t.j. že z.first je NULL - alebo neskôr)

void print(linkedList &z){
    node* x = z.first;
    while (x != NULL){
        printf(" %d", x->data);
        x = x->next;
    }
    printf("\n");
}

Prejsť celý zoznam potrebujeme aj v prípade, že chceme uvoľniť pamäť (napr. na konci programu).

void destroy(linkedList &z){
    while (z.first != NULL){
      node* p = z.first;
      z.first = z.first->next;
      delete p;
   }
}

Dá sa to aj funkciami, ktoré sme si už napísali:

void destroy(linkedList &z){
    while (!empty(z)){
      deleteFirst(z);
   }
}

Alebo rekurzívne:

void destroy(node *p) {
    if(p!=NULL) {
       destroy(p->next);
       delete p;
   }
}

void destroy(linkedList &z){
    destroy(z.first);
}

Utriedený zoznam

Občas sa nám hodí, aby sme si zoznam udržiavali utriedený. Pri vkladaní nového prvku potrebujeme najskôr nájsť miesto, kam patrí a vložiť ho tam.

Môžu nastať dva prípady:

Nový prvok patrí na začiatok zoznamu
- Toto sa stane ak je zoznam prázdny, alebo ak je nový prvok menší ako všetky, ktoré tam už sú
- Okrem vytvorenia nového uzla potrebujeme v zozname meniť položku first
Vkladáme niekde v strede alebo na konci zoznamu
- Potrebujeme poznať uzol, za ktorý vkladáme; jeho položku next totiž budeme meniť

void insert(linkedList& z, int data) {
    // vytvoríme nový uzol
    node* p = new node;
    p->data=data;

    // máme prázdny zoznam alebo vkladáme pred prvý prvok
    if (z.first==NULL || data < z.first->data) {
        p->next= z.first;
        z.first = p;
        return;
    }

    // prvok nepatrí na začiatok
    node* prev = z.first;
    // smerník prev posúvame až kým neukazuje na posledný prvok menší ako data
    while ((prev->next != NULL) && (prev->next->data < data)){
        prev = prev->next;
    }    
    p->next = prev->next;
    prev->next = p;
}

Riešenie ako je popísané je správne, avšak je náročné na napísanie, aby sme vyriešili špeciálne prípady. Tu sú dve možné riešenia, ako sa takýmto prípadom vyhnúť:

Použitie zarážky (sentinel node): pridáme špeciálny uzol na začiatok (v niektorých prípadoch aj na koniec) zoznamu, pričom hodnotu jeho kľúča nepoužívame.

prázdny zoznam teda obsahuje iba zarážku
každý uzol má predchodcu a každý zoznam má prvý uzol
vkladanie na začiatok znamená vložiť za zarážku
nikdy nemažeme úplne prvý prvok, lebo to je zarážka

Zarážky sa niekedy používajú aj pri práci v poli - do poľa si umelo vložíme špeciálny prvý alebo posledný prvok, čo zjednoduší program.

Smerník na smerník:

dva prípady v kóde vyššie oba nastavujú p->next a ešte nejaký iný smerník
z.first aj prev->next majú typ node *
vyrobíme si premennú typu node **, ktorá ukazuje na smerník, ktorý chceme potenciálne meniť
touto premennou sa pohybujeme po zozname, až kým nenájdeme správne miesto

void insert2(linkedList &z, int data){
    node* p = new node;
    p->data = data;

    node** it = &z.first;
    while (*it && (*it)->data < data) {
       it = &((*it)->next);
    }
    p->next = *it;
    *it = p;
}

Podobne vymazávame prvky zo zoznamu. Vo funkcii remove nájdeme a vymažeme prvok s určitou hodnotou zo zoznamu s utriedenými prvkami. Potrebné je si opäť pamätať jeho predchodcu, nakoľko tomuto prvku meníme nasledovníka.

void remove(linkedList &z, int data) {
    // prvok sa v zozname nenachádza resp. je zoznam prázdny
    if (!z.first || z.first->data > data) return; 

    // vymazávam prvý prvok
    if (data == z.first->data) {
        node* to_del = z.first;
        z.first = z.first->next;
        delete to_del;
        return;
    }

    // ostatné prípady
    node* prev = z.first;
    while (prev->next && prev->next->data < data) {
        prev = prev->next;
    }
    if (prev->next && prev->next->data == data) {
        node* to_del = prev->next;
        prev->next = prev->next->next;
        delete to_del;
    }
}

Cvičenie:

čo sa stane, ak je v zozname viac prvkov s hodnotou data?
čo treba zmeniť vo funkcii remove, aby mazala prvok s danou hodnotou aj so zoznamu, ktorý nie je usporiadaný?

Dvojsmerne spájaný zoznam

Je to typ spájaného zoznamu, v ktorom má každý uzol smerník na svojho nasledovníka a aj predchodcu. Ak je uzol prvý, hodnota smerníka na predchodcu má hodnotu NULL a obdobne, ak je uzol posledný, tak hodnota smerníka na nasledovníka je NULL.

Prvok zoznamu teda vyzerá takto:

struct node {
    int data;
    node* next;
    node* prev;
};

Obvykle sa potom okrem začiatku zoznamu udržuje aj smerník na koniec (teda posledný prvok zoznamu). Teda zoznam vyzerá nasledovne:

struct linkedList {
    node* first;
    node* last;
};

Pre inicializáciu je potrebné okrem začiatku nastaviť aj koniec. Uvoľňovanie pamäti funguje úplne rovnako ako v jednosmerne spájanom zozname.

Vkladanie a vymazávanie na začiatku

Vkladanie na začiatok podobne ako pri jednosmernom zozname, ale upravujeme viac smerníkov.

Podobne sa dá pracovať aj na konci zoznamu, keďže smerník na koniec si tiež udržujeme.

void insertFirst(linkedList &z, int d){
    node* p = new node;
    p->next = z.first;
    p->prev = NULL;
    p->data = d;
    if (z.first != NULL){
        z.first->prev = p;
    }
    else {
        z.last = p;
    }
    z.first = p;
}

Rozdiely oproti jednosmerne spájanému zoznamu:

Ak je zoznam prázdny, po vložení treba nastaviť smerník na koniec zoznamu.
Ak zoznam nie je prázdny, treba nastaviť predchádzajúci prvok pôvodnému začiatku, teda smerník (z.first)->prev.

Pri vymazávaní potrebujeme ošetriť, či sme nevymazali posledný prvok. V tom prípade potrebujeme nastaviť správne aj koniec zoznamu.

int deleteFirst(linkedList &z){
     /* zo zoznamu z vymaze prvy prvok a vrati jeho data */
     assert(z.first != NULL);      // nemozeme mazat, ak je zoznam prazdny
 
     node* p = z.first;           // prvok, ktorý ideme vymazat
     int d = z.first->data;       // to čo máme vrátiť
     z.first = z.first->next;     // presmerujeme zoznam na novy zaciatok
     if(z.first==NULL) z.last = NULL; 
     else z.first->prev = NULL;
     delete p;                    // uvoľnenie pamäte
     return d;
}

Prechádzanie zoznamu odpredu/odzadu

Na prechádzanie dvojsmerne spájaného zoznamu je možné použiť rovnaký postup ako pri prechádzaní jednosmerného. Okrem toho máme možnosť urobiť aj prechádzanie/výpis zoznamu odzadu.

void vypisOdzadu(linkedList &z){
    node* x = z.last;
    while (x != NULL){
        printf("%d ", x->data);
        x = x->prev;
    }
    printf("\n");
}

Vďaka tejto možnosti teda vieme napríklad jednoducho nájsť zoznamu k-ty prvok odzadu.

int kOdzadu(linkedList &z, int k){
    node* x = z.last;
    int data;
    for (int i = 0; i < k; i++){
      if (x == NULL) return -1;
      data = x->data;
      x = x->prev;
    }
    return data;
}

Cvičenie: ako by ste hľadali k-ty prvok odzadu v jednosmerne spájanom zozname?

Zhrnutie

V spájanom zozname máme uzly pospájané smerníkmi
Môžeme si do neho uložiť postupnosť prvkov aj keď nevieme vopred, aká bude dlhá
Cez zoznam môžeme ľahko prejsť, ale nevieme rýchlo skočiť niekam do stredu (toto zase vieme v poli)
Existuje veľa variantov: jednosmerne / obojsmerne spájané, kruhové, so sentinelmi, môžeme si pamätať začiatok alebo začiatok aj koniec...
Pozor na smerníky, aby všetky správne ukazovali a aby sa nám zoznam nepomotal
Príklady využitia zoznamov na ďalších prednáškach, napr. hašovanie, zásobník a rad.

Prednáška 17

Organizačné poznámky

Domáce úlohy: DÚ8 do piatku 22.11. 22:00, PDÚ3 do piatku 29.11. 22:00.
V priebehu týždňa bude zverejnená DÚ9 s termínom odovzdania do pondelku 2.12. 22:00.

Abstraktný dátový typ, ADT

Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií), nestaráme sa o implementáciu
Oddelíme tak samotnú implementáciu dátovej štruktúry a program, ktorý ju používa
Napríklad ADT vektor poskytuje operácie init, add, get, set, length a destroy
Pre jeden ADT môže byť viacero implementácií, napr. vector by sme mohli implementovať aj pomocou spájaného zoznamu
Program, ktorý vektor používa, netreba meniť kvôli zmene implementácie vektora

Dnes dve nové ADT: zásobník a rad

Obidve implementujeme pomocou polí aj spájaných zoznamov

Zásobník (stack) a rad (queue)

Jednoduché dátové štruktúry, ktoré udržujú zoznam nejakých prvkov
Tieto prvky sú dosť často úlohy, resp. dáta čakajúce na spracovanie
Vieme do nich vkladať a vyberať
Líšia sa tým, v akom poradí vyberáme

Rad, fronta (queue)

Vyberáme prvok, ktorý je v rade najdlhšie (first in, first out, FIFO)
Podobá sa na státie v rade pri pokladni: ten, kto tam stojí najdlhšie, bude prvý obslúžený
Základné operácie

/* inicializuje prázdny rad */
void init(queue &q);

/* zisti, ci je rad prazdny */
bool isEmpty(queue &q);

/* prida prvok item na koniec radu */
void enqueue(queue &q, dataType item); 

/* odoberie prvok zo začiatku radu a vráti jeho hodnotu */
dataType dequeue(queue &q);

/* vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q);

Zásobník (stack)

Vyberáme prvok, ktorý je v rade najkratšie (last in, first out, LIFO)
Podobá sa na umývača tanierov v reštaurácii, vždy vezme horný tanier z kopy

/* inicializuje prázdny zásobník */
void init(stack &s);

/* zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s);

/* prida prvok item na vrch zasobnika */
void push(stack &s, dataType item); 

/* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */
dataType pop(stack &q);

Ešte potenciálne potrebujeme uvoľniť pamäť nejakou ďalšou funkciou, napr. destroy, prípadne pre zložitejšie dataType createItem a destroyItem.

Príklad:

typedef int dataType;
/* sem pride definicia typov stack a queue a vsetky potrebne funkcie */

int main() {
    cout << "Stack:" << endl;
    stack s;
    init(s);
    push(s, 1);
    push(s, 2);
    push(s, 3);
    cout << pop(s) << endl;
    cout << pop(s) << endl;
    cout << pop(s) << endl;

    cout << "Queue:" << endl;
    queue q;
    init(q);
    enqueue(q, 1);
    enqueue(q, 2);
    enqueue(q, 3);
    cout << dequeue(q) << endl;
    cout << dequeue(q) << endl;
    cout << dequeue(q) << endl;
}

Zásobník prevracia poradie prvkov, rad zachováva.

Stack:
3
2
1
Queue:
1
2
3

Zásobník implementovaný pomocou poľa

Dve prirodzené možnosti:

vrch zásobníka v prvku 0
spodok zásobníka v prvku 0

Prvá možnosť by bola pomalá, na operácie push aj pop by sme museli posúvať všetky prvky v zásobníku. Použijeme teda druhú možnosť, v prvku 0 bude spodok zásobníka, v premennej top si pamätáme pozíciu vrchného prvku.

struct stack {
    int top;  /* pozicia vrchného prvku zásobníka */
    dataType *items; /* pole prvkov */
};

/* inicializuje prázdny zásobník */
void init(stack &s) {
    s.top = -1;
    s.items = new dataType[maxN];
}

/* zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s) {
    return s.top == -1;
}

/* prida prvok s hodnotou item na vrch zasobnika */
void push(stack &s, dataType item) {
    s.top++;
    assert(s.top < maxN);
    s.items[s.top] = item;
}

/* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */
dataType pop(stack &s) {
    assert(s.top >= 0);
    s.top--;
    return s.items[s.top + 1];
}

Rad implementovaný pomocou poľa

Rad sa nedá implementovať tak jednoducho ako zásobník, lebo na jednej strane potrebujeme vkladať a na druhej vyberať.
Takže ak by sme chceli mať napr. prvý prvok v rade vždy na pozícii 0, museli by sme pri vyberaní posúvať všetky prvky, čo je pomalé.
Namiesto toho si budeme pamätať pozíciu prvého prvku (premenná first) a keď vyberieme prvok, len zvýšime first
Tým sa zaplnený úsek postupne posúva doprava
Keď dôjdeme na koniec poľa, zatočíme sa, ako keby za prvkom maxN-1 nasledoval prvok 0

struct queue {
    int first;  /* pozícia prvého prvku v rade */
    int count;  /* počet prvkov v rade */
    dataType *items; /* pole prvkov */
};

/* inicializuje prázdny rad */
void init(queue &q) {
    q.first = 0;
    q.count = 0;
    q.items = new dataType[maxN];
}

/* zisti, ci je rad prazdny */
bool isEmpty(queue &q) {
    return q.count == 0;
}

/* prida prvok s hodnotou item na koniec radu */
void enqueue(queue &q, dataType item) {
    assert(q.count < maxN);
    int last = (q.first + q.count) % maxN;
    q.items[last] = item;
    q.count++;
}

/* odoberie prvok zo začiatku radu a vráti jeho hodnotu */
dataType dequeue(queue &q) {
    assert(q.count > 0);
    int index = q.first; /* kde je prvok, ktory chceme vratit */
    q.first = (q.first + 1) % maxN;
    q.count--;
    return q.items[index];
}

/* vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q) {
    assert(q.count > 0);
    return q.items[q.first];
}

Zásobník implementovaný pomocou spájaného zoznamu

V zásobníku v poli sme na začiatku poľa mali spodok zásobníka
V zozname budeme mať na začiatku zoznamu vrchol zásobníka, lebo na začiatok zoznamu sa dobre vkladá a vyberá.
Použijeme kód na vkladanie a vyberanie zo zoznamu z prednášky 16 (začiatok zoznamu sme premenovali na top)
Nepotrebujeme vopred stanoviť maximálny počet prvkov, zásobník podľa potreby rastie alebo sa zmenšuje (kým je voľná pamäť)

struct node {
    dataType data;
    node* next;
};

struct stack {
    node *top; /* vrchný prvok zásobníka */
};

/* inicializuje prázdny zásobník */
void init(stack &s) {
    s.top = NULL;
}

/* zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s) {
    return s.top == NULL;
}

/* prida prvok s hodnotou item na vrch zasobnika */
void push(stack &s, dataType item) {
    node *temp = new node;
    temp->data = item;
    temp->next = s.top;
    s.top = temp;
}

/* odoberie prvok z vrchu zásobníka a vráti jeho hodnotu */
dataType pop(stack &s) {
    assert(s.top != NULL);
    node *temp = s.top->next; // prvok, ktorý bude ďalej top
    dataType val = s.top->data; // to čo máme vrátiť
    delete s.top;
    s.top = temp;
    return val;
}

Rad implementovaný pomocou spájaného zoznamu

Potrebujeme na jednom konci zoznamu vkladať, na opačnom vyberať.
Použijeme kruhový zoznam, v ktorom posledný prvok ukazuje pomocou next na prvý prvok v zozname.
Prvý prvok radu bude prvý v zozname, bude ukazovať na druhý prvok atď.
V štruktúre queue si pamätáme iba smerník na posledný prvok radu.
- Ak je rad prázdny, tento smerník je NULL.
- Z posledného prvku sa jedným krokom vieme dostať k prvému prvku.

struct queue {
    node *last; /* posledný prvok v rade */
};

/* inicializuje prázdny rad */
void init(queue &q) {
    q.last = NULL;
}

/* zisti, ci je rad prazdny */
bool isEmpty(queue &q) {
    return q.last == NULL;
}

/* prida prvok s hodnotou item na koniec radu */
void enqueue(queue &q, dataType item) {
    node *temp = new node;
    temp->data = item;
    if (q.last == NULL) {
        q.last = temp;
        temp->next = temp;
    } else {
        temp->next = q.last->next;
        q.last->next = temp;
        q.last = temp;
    }
}

/* odoberie prvok zo začiatku radu a vráti jeho hodnotu */
dataType dequeue(queue &q) {
    assert(q.last != NULL);
    node *first = q.last->next;
    if (first->next == first) { /* ak v zozname iba jeden prvok */
        q.last = NULL;
    } else { /* v zozname viac prvkov, preskocime first */
        q.last->next = first->next;
    }
    dataType val = first->data;
    delete first; /* zmazeme node pre first */
    return val;
}

/* vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q) {
    assert(q.last != NULL);
    return q.last->next->data;
}

Použitie rady a zásobníka

Zvyčajne uchovávajú dáta, ktoré ešte treba spracovať, resp. zoznam úloh.

Rad použijeme, ak chceme zachovať poradie.

Jeden proces pridáva úlohy, druhý ich rieši (prípadne aj viac procesov môže vkladať alebo vyberať)
Príklady:
- Textový procesor pripravuje strany na tlač, vkladá ich do radu, tlačiareň ich tlačí
- Výpočtové úlohy čakajú na veľkom serveri v rade na spustenie
- Zákazníci čakajú na zákazníckej linke na voľného operátora
- Pasažieri na stand-by čakajú na voľné miesto v lietadle

Zásobník je jednoduchší, používame ho, ak nám nezáleží na poradí, alebo ak chceme poradie prevracať

Hlavný príklad je zásobník, ktorý kompilátor vytvorí na ukladanie lokálnych premenných funkcií, čo nám umožňuje použiť rekurziu (call stack)
Pri nekonečnej rekurzii nám zásobník "pretečie" a program spadne, napr. s chybou Segmentation fault

void pokus() {
    int i;
    pokus();
}

int main() {
    pokus();
}

Rekurzívne programy vieme prepísať na nerekurzívne, napríklad pomocou ručne vytvoreného zásobníka
- Mohli by sme mechanicky simulovať to, ako zásobník používa kompilátor, to by však bolo veľmi neprehľadné
- Väčšinou trochu zmeníme ako presne program funguje
- Ukážeme si niekoľko príkladov

Nerekurzívny QuickSort

Quicksort zvolí nejakú hodnotu, prvky menšie ako táto hodnota dá do ľavej časti poľa, väčšie prvky do pravej časti poľa
Potom rekurzívne volá Quicksort na obe časti poľa

void quicksort(int A[], int l, int r) {
    if (l >= r) return;

    // rozdelenie
    int pivot = divide(A, l, r);

    // reukrzivne volanie na mensie a vacsie prvky
    quicksort(A, l, pivot - 1);
    quicksort(A, pivot + 1, r);
}
int main() {
  ...
  quicksort(A, 0, n-1);
  ...
}

Namiesto rekurzie si spravíme zásobník dvojíc l,r, ktoré ešte treba dotriediť

struct usek {
    int l, r;
};

typedef usek dataType;

void quicksort(int A[], int n) {
    stack s;
    init(s);
    
    /* do stacku vlozime usek pre cele pole */
    usek u;
    u.l = 0;
    u.r = n - 1;
    push(s, u);

    while (!isEmpty(s)) {
        u = pop(s);
        /* spracovavame usek od u.l po u.r */
        if (u.l >= u.r) continue;

        /* rozdelenie */
        int pivot = divide(A, u.l, u.r);

        /* ľavý a pravý úsek vložíme do stacku na neskoršie dotriedenie */
        usek u1;
        u1.l = u.l;
        u1.r = pivot - 1;
        usek u2;
        u2.l = pivot + 1;
        u2.r = u.r;
        push(s, u2);
        push(s, u1);
    }
}

Tento program triedi úseky v rovnakom poradí, ako rekurzívny Quicksort, lebo po rozdelení intervalu [0..n-1] na dve časti dá na vrchol zásobníka ľavú časť. Až keď sa táto ľavá časť a všetky podúlohy, ktoré z nej vzniknú, spracuje, vytiahne sa zo zásobníka pravá časť.
V Quicksorte však na poradí nezáleží, takže by sme mohli vložiť úseky aj naopak push(s, u1); push(s, u2); (potom by najprv dotriedil pravú časť až potom ľavú)
Alebo by sme namiesto zásobníka mohli použiť rad. Potom by najskôr rozdelil ľavú aj pravú časť na ďalšie podčasti a potom by delil každú z týchto podčastí atď

Na zamyslenie: ako by sme spravili nerekurzívny MergeSort? Prečo to nejde tak isto ako Quicksort?

Kontrola uzátvorkovania

Jednoduchý príklad na použitie zásobníka
Máme daný reťazec obsahujúci zátvorky rôznych typov (,),[,],{,} a chceme zistiť, či je dobre uzátvorkovaný
Ak zoberieme prvých i znakov reťazca, počet uzátvaracích zátvoriek nesmie prevýšiť počet otváracích
Ku každej otváracej zátvorke musí byť zatváracia toho istého typu

+2
Vyraz je dobre uzatvorkovany

(x+2)
Vyraz je dobre uzatvorkovany

[((({}[])[]))]
Vyraz je dobre uzatvorkovany

[[#))
Vyraz nie je dobre uzatvorkovany

())(
Vyraz nie je dobre uzatvorkovany

((
Vyraz nie je dobre uzatvorkovany

Do zásobníka si budeme ukladať pre každú začínajúcu zátvorku jej zodpovedajúcu končiacu. Keď príde končiaca zátvorka, skontrolujeme, či na vrchu zásobníka je to isté (a vyberieme to zo zásobníka).

typedef char dataType;
/* tu vlozime deklaracie a funkcie pre zasobnik */

int main(){
    char vyraz[100];
    fgets(vyraz, 100, stdin);  // nacitame retazec do pola vyraz
    stack s;
    init(s);
    bool spravny = true;
    for (int i = 0; vyraz[i] != 0; i++) {
        switch (vyraz[i]) {
            case '(':
                push(s, ')');
                break;
            case '[':
                push(s, ']');
                break;
            case '{':
                push(s, '}');
                break;
            case ')':
            case ']':
            case '}':
                if (isEmpty(s)) {
                    spravny = false;
                } else {
                    char c = pop(s);
                    if (c != vyraz[i]) {
                        spravny = false;
                    }
                }
                break;
        }
    }
    if (spravny) {
        cout << "Vyraz je dobre uzatvorkovany" << endl;
    } else {
        cout << "Vyraz nie je dobre uzatvorkovany" << endl;
    }
}

Cvičenie:

Čo spraví program, ak na vstupe je ((? Opravte ho, aby fungoval správne.
Pridajte do programu výpis pozície, kde bola detekovaná chyba a výpis typu chyby.
Prepíšte program na kontrolu zátvoriek do rekurzívnej podoby, pričom použijete iba premenné typu char (žiadne polia a pod.). Reťazec načítavajte pomocou getc a ungetc, ukončený je koncom riadku.

Cvičenia 9

Smerníky a typy

Majme nasledujúce definície premenných:

struct volaco { 
    int x;
    int *y;
};
volaco * a[3];  // pole 3 smernikov na volaco
volaco v;       
volaco *p;

Akých typov sú nasledovné výrazy? (t.j. napr. do premennej akého typu by sme ich mohli priradiť?)

*(p->y)
&(v.x)
&(a[2])
p->y[p->x]

Skúste inicializovať premenné a, v a p (a príslušné časti structov volaco) tak, aby všetky tieto výrazy pracovali len s platnými miestami v pamäti.

Valgrind

Nasledujúci program nesprávne odalokováva pamäť. Spustite ho v programe valgrind, mal by vám oznámiť dva problémy:

Invalid free() / delete / delete[] / realloc() Čo to asi znamená? Na ktorom riadku programu je chyba?
LEAK SUMMARY: definitely lost: 4 bytes in 1 blocks Čo to asi znamená? (memory leak je pamäť, ktorú sme neodalokovali a ku ktorej sa už nevieme dostať cez žiadnu premennú).
- Tento problém môžete bližšie preskúmať, ak spustíme valgrind takto: valgrind --leak-check=full cesta/meno_programu
- Mali by ste potom dostať hlášku typu 4 bytes in 1 blocks are definitely lost in loss record 1 of 1 s bližším určením, na ktorom mieste programu bola táto stratená pamäť alokovaná

int main(void) {
    int i;
    int *p = new int;
    int *q = new int;
    int *r = p;
    delete p;
    delete r;
}

2D polia

Vytvorte Pascalov trojuholník ako 2D pole, ktoré má v prvom riadku jedno číslo Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {0 \choose 0}} , v druhom dve Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {1 \choose 0}} a Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {1 \choose 1}} atď. Môžete využiť vzťah, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n \choose 0} = {n \choose 0} = 1} a pre 0<k<n platí Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle {n \choose k} = {n-1 \choose k-1} + {n-1 \choose k}} , t.j. n-tý riadok vieme ľahko spočítať z n-1-vého.
Do programu s výškovou mapou z prednášky 15 doprogramujte hľadanie všetkých ostrovčekov veľkosti 1, t.j. políčka s pevninou, ktoré sa hranou nedotýkajú inej pevniny (môžu sa dotýkať rohom). Každý taký ostrovček zarámikujte. Spravte si vstup, v ktorom takéto ostrovčeky budú, aby ste mohli program vyskúšať.

Ešte valgrind a hľadanie chýb

Nasledujúci program by mal správne vypísať text "AhojAhojAhojAhoj", ale je v ňom zopár chýb. Skúste nájsť a opraviť chyby čítaním programu, použitím debugera, programu valgrind, prípadne si pridajte nejaké pomocné výpisy premenných.

#include <iostream>
using namespace std;

void opakuj(char kam[], char co[], char kolko) {
    /* Funkcia dostane na vstupe retazec co a cislo kolko a nakopiruje ho tolkokrat
     * za sebou do retazca kam. */

    int i=0; // pozicia v kam
    for(int opakovanie=0; opakovanie<kolko; opakovanie++) {  // opakuj kopirovanie
        for(int j=0; co[j]!=0; j++) {  // prechod cez znaky retazca co
            kam[i] = co[j];
            i++;
        }        
    }
}

int main(void) {
    char ahoj[4] = {'A', 'h', 'o', 'j'};
    char vysledok[16];  
    opakuj(vysledok, ahoj, 4);
    cout << vysledok << endl;
}

Matice

Napíšte funkcie, ktoré dostanú na vstupe dvojrozmernú maticu celých čísel s n riadkami a m stĺpcami a spravia s ňou jednu z týchto operácií:

Otočte poradie riadkov matice (stačí vymeniť smerníky)
Otočte poradie stĺpcov matice (treba vymienať čísla v riadkoch)
Zostavte transponovanú maticu, t.j. s m riadkami a n stĺcami

Na testovanie vášho programu môžete použiť funkcie na prácu s maticami z prednášky 15.

Vektor

Do programu na prácu s vektorom z prednášky 14 doprogramujte funkciu void removeLast(vector &a), ktorá z poľa vyhodí posledný prvok (zmenší sa teda n) a ak bude n menší ako tretina veľkosti, vytvorí nové pole polovičnej veľkosti, zvyšné prvky do neho premiestni, a staré pole uvoľní. Pole by malo mať vždy veľkosť aspoň 1.

2D vektor

Vytvorte dvojrozmerný vektor, ktorý bude podporovať nasledovné operácie:
- Inicializuj: Nastaví počiatočnú použiteľnú veľkosť na 2x2, N(počet riadkov)=0 a M(počet stĺpcov)=0.
- Pridaj riadok: Ak sa do súčasnej veľkosti zmestí, pridá riadok (zväčší N) obsahujúci M núl. Ak sa nezmestí, zdvojnásobí počet riadkov.
- Pridaj stĺpec: Ak sa do súčasnej veľkosti zmestí, pridá stĺpec (zväčší M) obsahujúci N núl. Ak sa nezmestí, zdvojnásobí počet stĺpcov.
- Prístup k prvku na riadku i a stĺpci j (funkcie get a set)
- Uvoľni: Uvoľní pamäť.

Hra Life

Na konci prednášky 15 je program na simulovanie hry Life.

Prečítajte si popis tejto hry a skúste si spustiť príslušný program
Zobrazovanie hry Life zmeňte tak, aby sa bunky, ktoré práve umreli, zobrazili ako sivé políčka a až v ďalšom kroku zmizli úplne. (T.j. v čase t bunka žije, teda je čierne, v čase t+1 umrela teda je sivá a v čase t+2 bude bielou, ak sa znova nenarodila). Pre jednoduchosť môžete v každom kole zmazať obrázok a vykresľovať všetky políčka odzova.

Prednáška 18

Vyfarbovanie súvislých oblastí

Máme daný obrázok pozostávajúci z m riadkov a n stĺpcov pixelov, každý pixel určitej farby. V našom jednoduchom príklade budeme uvažovať iba 4 farby, ktoré budeme zapisovať číslami 0,..,3 a ktorých význam bude daný týmto poľom, takže napr. farba 0 je biela:

const char * farby[4] = {"white", "green", "black", "brown"};

Užívateľ si zvolí určitý pixel obrázku a chce vyfarbiť celú súvislú jednofarebnú oblasť obsahujúcu tento pixel novou farbou. Ak napríklad začneme vyfarbovať v obrázku vľavo farbou 3 (hnedou) od pixelu (0,0), dostaneme obrázok napravo:

Tu je pôvodný obrázok v textovej forme, ako matica čísel.

11 17
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0
 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0
 0 0 0 1 0 0 0 0 0 2 2 1 2 2 2 2 0
 0 0 0 1 0 0 0 0 0 2 0 1 0 0 0 2 0
 0 2 2 2 2 2 2 2 0 2 2 1 2 2 2 2 0
 0 2 0 1 0 0 0 2 0 0 0 1 0 0 0 0 0
 0 2 0 1 0 0 0 2 0 0 0 1 0 1 1 1 1
 0 2 0 1 1 1 1 2 1 1 1 1 0 1 0 0 1
 0 2 0 0 0 0 0 2 0 0 0 0 0 1 1 1 1
 0 2 2 2 2 2 2 2 0 0 0 0 0 0 0 0 0

Túto úlohu vieme vyriešiť nasledujúcou rekurzívnou funkciou, ktorá prefarbí zadané políčko a potom rekurzívne pokračuje vo vyfarbovaní vo všetkých susedoch, ktorí majú rovnakú farbu, ako pôvodne malo toto políčko.

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu 
     * a[riadok][stlpec] na farbu farba */

    if (a[riadok][stlpec] != farba) {
        int stara_farba = a[riadok][stlpec];
        a[riadok][stlpec] = farba;
        if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok - 1, stlpec, farba);
        }
        if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok + 1, stlpec, farba);
        }
        if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec - 1, farba);
        }
        if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec + 1, farba);
        }
    }
}

Susedov náš program pozerá v poradí hore, dole, doľava, doprava.

V akom poradí vyfarbí políčka nulovej matice 2x2 ak začne v ľavom hornom rohu?
V akom poradí vyfarbuje jednoriadkovú maticu, ak začneme niekde v strede?

Zdrojový kód celého programu

Tento program vytvorí maticu a vyfarbí v ňom jednu oblasť aj s SVG animáciou: #Program rekurzívne vyfarbovanie
Animácia

Použitie vyfarbovania na mape

Spomeňme si na program na prácu s výškovou mapu z prednášky 15. Máme zadanú mapu ako maticu celých čísel, v ktorej 0 znamená more a kladné čísla nadmorskú výšku pevniny. Budeme predpokladať, že na mape je niekoľko ostrovov, ktoré sú plne obkolesené morom a nemajú žiadne vnútorné moria ani jazerá. Chceme spočítať, koľko tam tých ostrovov je.

Použijeme na to vyfarbovanie z predchádzajúceho programu.

Prejdeme maticu a všetky kladné čísla prepíšeme na 1. Máme teda 0 vyznačené more a 1 ostrovy.
Prechádzame maticu a vždy, keď nájdeme 1 (ešte nepreskúmaný ostrov), vyfarbíme ho farbou 2 a zvýšime počet ostrovov.
Nakoniec máme more ako 0 a všetky ostrovy ako 2.

Príklad mapy a jej zobrazenie po prepísaní kladných čísel na 1 (zelená), po vyfarbení prvého ostrova číslom 2 (čiernou) a po vyfarbení všetkých ostrovov.

11 17
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 1 9 1 1 1 0 0 1 1 0 0 0 0 0
 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0
 0 0 0 1 0 0 0 0 0 1 1 1 0 0 1 1 0
 0 0 0 1 0 0 0 0 0 2 0 0 0 0 0 1 0
 0 1 0 0 2 2 2 2 0 2 2 1 7 1 1 1 0
 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 7 0 1 0 0 0 2 0 0 0 1 0 1 1 1 0
 0 0 0 1 5 1 1 2 1 1 3 1 0 1 2 2 0
 0 1 0 0 0 1 1 2 2 0 0 0 0 1 1 1 0
 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Takto to naprogramujeme:

   for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            if(a[i][j]>0) a[i][j] = 1;
        }
    }

    int ostrovov = 0;
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            if(a[i][j]==1) {
                ostrovov++;
                vyfarbi(a, n, m, i, j, 2);
            }
        }
    }
    cout << "Pocet ostrovov: " << ostrovov << endl;

Cvičenie:

Ako by ste zistili, či má nejaký ostrov jazero?

Zdrojový kód celého programu

Tento program načíta maticu a zobrazuje vyfarbovanie ostrovov: #Ukážkový program ostrovy
Animácia

Nerekurzívne vyfarbovanie

Prepíšme najskôr štyri volania rekurzívne do jedného cyklu pomocou polí delta_riadok a delta_stlpec.

const int delta_stlpec[4] = {1, 0, -1, 0};
const int delta_riadok[4] = {0, -1, 0, 1};

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu
     * a[riadok][stlpec] na farbu farba */

    if (a[riadok][stlpec] != farba) {
        int stara_farba = a[riadok][stlpec];
        a[riadok][stlpec] = farba;
        for (int smer = 0; smer < 4; smer++) {
            /* skus susedne policko so suradnicami r,s */
            int r = riadok + delta_riadok[smer];
            int s = stlpec + delta_stlpec[smer];
            if (r >= 0 && r < n && s >= 0 && s < m && a[r][s] == stara_farba) {
                vyfarbi(a, n, m, r, s, farba);
            }
        }
    }
}

Namiesto rekurzie budeme používať zásobník. Do zásobníka si môžeme uložiť štyroch susedov aktuálneho políčka, pretože z nich ešte treba vyfarbovať ďalej. Ale spravíme malú zmenu: pred uložením do stacku ich už prefarbíme novou farbou, aby sme vedeli, že ich už viackrát do zásobníka nemáme dať.

/* struct so suradnicami policka, ktory budeme ukldat do zasobnika */
struct policko {
    int r, s;
};

typedef policko dataType;

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu
     * a[riadok][stlpec] na farbu farba */

    stack s;
    init(s);

    /* vyfarbi startovacie policko a daj ho do stacku */
    int stara_farba = a[riadok][stlpec];
    if (stara_farba == farba) return;
    a[riadok][stlpec] = farba;
    policko p;
    p.r = riadok;
    p.s = stlpec;
    push(s, p);

    while (!isEmpty(s)) {
        /* vytiahni policko zo stacku */
        p = pop(s);
        /* skontroluj jeho susedov, vyfarbi ich a uloz to stacku */
        for (int smer = 0; smer < 4; smer++) {
            policko p2;
            p2.r = p.r + delta_riadok[smer];
            p2.s = p.s + delta_stlpec[smer];
            if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m
                    && a[p2.r][p2.s] == stara_farba) {
                a[p2.r][p2.s] = farba;
                push(s, p2);
            }
        }
    }
}

Namiesto zásobníka môžeme použiť aj rad, potom bude vyfarbovať v poradí podľa vzdialenosti od štartovacieho políčka (prehľadávanie do šírky)

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu
     * a[riadok][stlpec] na farbu farba */

    queue q;
    init(q);

    /* vyfarbi startovacie policko a daj ho do radu */
    int stara_farba = a[riadok][stlpec];
    if (stara_farba == farba) return;
    a[riadok][stlpec] = farba;
    policko p;
    p.r = riadok;
    p.s = stlpec;
    enqueue(q, p);

    while (!isEmpty(q)) {
        /* vytiahni policko z radu */
        p = dequeue(q);
        zobrazStvorcek(p.r, p.s, a[p.r][p.s], "lightgray", window);
        window.wait(waitTime);
        /* skontroluj jeho susedov, vyfarbi ich a uloz to radu */
        for (int smer = 0; smer < 4; smer++) {
            policko p2;
            p2.r = p.r + delta_riadok[smer];
            p2.s = p.s + delta_stlpec[smer];
            if (p2.r >= 0 && p2.r < n && p2.s >= 0 && p2.s < m
                    && a[p2.r][p2.s] == stara_farba) {
                a[p2.r][p2.s] = farba;
                enqueue(q, p2);
                zobrazStvorcek(p2.r, p2.s, a[p2.r][p2.s], "red", window);
                window.wait(waitTime);
            }
        }
    }
}

Sudoku

Na precvičenie matíc, rekurzie a prehľadávania s návratom si ukážeme ešte program na riešenie hlavolamu Sudoku.

Máme danú plochu 9x9 políčok, pričom niektoré sú prázdne, iné obsahujú číslo z množiny {1..9}. Plocha je rozdelená do 9 štvorcov 3x3. Cieľom je doplniť čísla do prázdnych štvorčekov tak, aby v každom riadku plochy, v každom stĺpci plochy a v každom štvorci 3x3 bola každá cifra {1..9} práve raz.

. 3 . | . 7 . | . . .
6 . . | 1 9 5 | . . .
. 9 8 | . . . | . 6 .
---------------------
8 . . | . 6 . | . . 3
4 . . | 8 . 3 | . . 1
. . . | . 2 . | . . 6
---------------------
. 6 . | . . . | 2 8 .
. . . | 4 . 9 | . . 5
. . . | . 8 . | . 7 .

Príklad vstupu a výstupu:

Vstup:                   Vystup:
0 3 0 0 7 0 0 0 0	 5 3 4 6 7 8 9 1 2
6 0 0 1 9 5 0 0 0	 6 7 2 1 9 5 3 4 8
0 9 8 0 0 0 0 6 0	 1 9 8 3 4 2 5 6 7
8 0 0 0 6 0 0 0 3	 8 5 9 7 6 1 4 2 3
4 0 0 8 0 3 0 0 1	 4 2 6 8 5 3 7 9 1
0 0 0 0 2 0 0 0 6	 7 1 3 9 2 4 8 5 6
0 6 0 0 0 0 2 8 0	 9 6 1 5 3 7 2 8 4
0 0 0 4 0 9 0 0 5	 2 8 7 4 1 9 6 3 5
0 0 0 0 8 0 0 7 0        3 4 5 2 8 6 1 7 9

                         Pocet rieseni: 1

Naša rekurzívna procedúra bude postupovať nasledovne:

nájde na ploche prázdne políčko, ak také nie je, vypíše riešenie a skončí
do prázdneho políčka skúša vložiť čísla 1...9 a testuje, či nenastane konflikt v riadku, stĺpci alebo štvorci
ak niektoré číslo sedí, zavolá sa rekurzívne na vyplnenie zvyšných bielych miest

void generuj(int **a) {
    int r, s;
    najdiVolne(a,r,s);
    if (r < 0) {
        vypis(a);
    } else {
        for (int x = 1; x <= 9; x++) {
            if (moze(a, r, s, x)) {
                a[r][s] = x;
                generuj(a);
                a[r][s] = 0;
            }
        }
    }
}

Nájdenie voľného miesta v tabuľke urobíme jednoduchým prechodom matice a hľadaním miesta, ktoré má hodnotu 0. Jeho súradnice uložíme do premenných r, s ak také existuje. V opačnom prípade nastavíme r=s=-1.

Funkcia moze prechádza riadok, stĺpec a štvorec, do ktorého patrí miesto, ktoré práve obsadzujeme. Zisťuje, či sa potenciálny kandidát nenachádza už niekde inde.

bool moze(int **a, int riadok, int stlpec, int hodnota) {
    /* Mozeme ulozit danu hodnotu na dane policko?
     * Da sa to, ak riadok, stlpec, ani stvorec nema
     * tuto hodnotu este pouzitu. */
    for (int i = 0; i < 9; i++) {
        if (a[riadok][i] == hodnota) return false;
        if (a[i][stlpec] == hodnota) return false;
    }
    /* lavy horny roh stvorca */
    int riadok1 = riadok - riadok % 3;
    int stlpec1 = stlpec - stlpec % 3;
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (a[riadok1 + i][stlpec1 + j] == hodnota) return false;
        }
    }
    return true;
}

Úpravy v sudoku

Plochu zodpovedajúcu sudoku si nebudeme ukladať ako dvojrozmerné pole veľkosti 9x9, ale ako jednorozmerné veľkosti 9*9=81, kde miesto plocha[i] bude zodpovedať pôvodnému a[i/9][i%9]
- Pozícia na ploche bude teda daná iba jedným číslom, čo nám uľahčí niektoré časti programu
Tiež si môžeme pamätať, ktoré čísla sú už obsadené v riadku, stĺpci a štvorci, takže to nebudeme musieť zdĺhavo testovať.

Namiesto globálnych premenných si vytvoríme struct sudoku, do ktorého uložíme všetky potrebné údaje pre rekurzívne vyhľadávanie.

struct policko {
    int riadok, stlpec, stvorec;
    int hodnota;
};

struct sudoku {
    policko *plocha;  /* pole vsetkych policok plochy */
    bool **obsadeneRiadok;  /* pre kazdy riadok ci je dana cifra uz pouzita */
    bool **obsadeneStlpec;  /* pre kazdy stlpec ci je dana cifra uz pouzita */
    bool **obsadeneStvorec; /* pre kazdy stvorec ci je dana cifra uz pouzita */
    int pocetPolicok; /* celkovy pocet policok (9*9) */
    int pocet;        /* celkovy pocet riadkov,stlpcov a stvorcov (9) */
    int rieseni;      /* pocet najdenych rieseni */
};

Hneď pri inicializácii si musíme pre každé políčko povedať, kam vlastne patrí. Predpokladajme, že zadanie máme v dvojrozmernom poli a.

void inicializuj(sudoku &s, int **a) {
    /* inicializuj strukturu sudoku na zaklade
     * vstupnej matice s cislami 0..9*/
    s.pocetPolicok = 9 * 9;
    s.pocet = 9;
    /* alokujeme polia a oznacime cifry ako neobsadene */
    s.plocha = new policko[s.pocetPolicok];
    s.obsadeneRiadok = new bool*[s.pocet];
    s.obsadeneStlpec = new bool*[s.pocet];
    s.obsadeneStvorec = new bool*[s.pocet];
    for (int i = 0; i < s.pocet; i++) {
        s.obsadeneRiadok[i] = new bool[10];
        s.obsadeneStlpec[i] = new bool[10];
        s.obsadeneStvorec[i] = new bool[10];
        for (int j = 1; j <= 9; j++) {
            s.obsadeneRiadok[i][j] = false;
            s.obsadeneStlpec[i][j] = false;
            s.obsadeneStvorec[i][j] = false;
        }
    }
    /* pre kazde policko naplnime jeho strukturu
     * a vyplnime obsadene cifry */
    int pozicia = 0;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            s.plocha[pozicia].riadok = i;
            s.plocha[pozicia].stlpec = j;
            s.plocha[pozicia].stvorec = (i / 3)*3 + (j / 3);
            uloz(s, pozicia, a[i][j]);
            pozicia++;
        }
    }
    /* este sme nenasli ziadne riesenie */
    s.rieseni = 0;
}

Rekurzia už potom musí okrem priradenia hodnoty na políčko obhospodáriť aj obsadenosť daného čísla v riadku, stĺpci a štvorci. Bude teda vyzera takto:

void generuj(sudoku &s) {
    int i = najdiVolne(s);
    if (i < 0) {
        vypis(s);
    } else {
        for (int x = 1; x <= 9; x++) {
            if (moze(s, i, x)) {
                uloz(s, i, x);
                generuj(s);
                zmaz(s, i, x);
            }
        }
    }
}

Nájdenie voľného miesta ostáva podobné, ako v predchádzajúcom prípade.
Uloženie alebo zmazanie hodnoty musí okrem priradenia hodnoty upraviť aj hodnoty v obsadeneRiadok, obsadeneStlpec a obsadeneStvorec. Funkcia uloz teda vyzerá nasledovne (funkcia zmaz analogicky):

void uloz(sudoku &s, int pozicia, int hodnota) {
    s.plocha[pozicia].hodnota = hodnota;
    if (hodnota > 0) {
        int riadok= s.plocha[pozicia].riadok;
        int stlpec= s.plocha[pozicia].stlpec;
        int stvorec= s.plocha[pozicia].stvorec;
        s.obsadeneRiadok[riadok][hodnota] = true;
        s.obsadeneStlpec[stlpec][hodnota] = true;
        s.obsadeneStvorec[stvorec][hodnota] = true;     
    }
}

Funkcia moze() sa nám naopak zjednoduší. Na určenie, či hodnotu x môžeme priradiť na políčko p nám stačí skontrolovať či s.obsadeneRiadok[p.riadok], s.obsadeneStlpec[p.stlpec] aj s.obsadeneStvorec[p.stvorec] sú false.

Ešte si to zoptimalizujeme

Vidíme, že obsadeneRiadok, obsadeneStlpec aj obsadeneStvorec sú veľmi podobné polia. Môžeme si teda vytvoriť pole, ktoré celkovo popisuje obsadené prvky v ľubovoľnej skupine. Každý prvok potom má určené svoje skupiny do ktorých patrí (už nie tromi premennými riadok, stlpec, stvorec ale v poli, ktoré obsahuje indexy skupín v poli obsadene, kam políčko patrí).

Výsledný program je tu: #Program Sudoku

Takýmto spôsobom si vieme pridávať ďalšie požiadavky na naše riešenie sudoku.
Čo by bolo treba zmeniť v programe, aby zakazoval opakujúce sa cifry aj na hlavnej diagonále celej plochy?

Dalšie možné úpravy

Zlepšite algoritmus tak, aby nezačínal vždy s prvým prázdnym políčkom, ale s takým, ktoré má najmenej neobsadených možností (v ideálnom prípade 1). Ak má niektoré nevyplnené políčko 0 možností, môžeme túto vetvu hľadania tiež ukončiť.

Program rekurzívne vyfarbovanie

#include "../SVGdraw.h"
#include <cstdio>

const char* farby[4] = {"white", "green", "black", "brown"};
/* velkost stvorceka mapy v pixeloch */
const int stvorcek = 15;
/* cakanie po kazdom kroku vysvetlovania */
double waitTime = 0.3;

int ** vytvorMaticu(int n, int m) {
    /* vytvor maticu s n riadkami a m stlpcami */
    int **a;
    a = new int *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }
    return a;
}

void zmazMaticu(int n, int m, int **a) {
    /* uvolni pamat matice s n riadkami a m stlpcami */
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
}

void zobrazStvorcek(int i, int j, int farba, const char* farbaCiary, SVGdraw &drawing) {
    /* zobraz stvorcek v riadku i a stlpci j */
    drawing.setLineColor(farbaCiary);
    drawing.setFillColor(farby[farba]);
    drawing.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek);
}

void zobrazMaticu(int **a, int n, int m, SVGdraw &drawing) {
    /* zobraz vsetky stvorceky matice */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            zobrazStvorcek(i, j, a[i][j], "lightgray", drawing);
        }
    }
}

void obdlznik(int **a, int riadok, int stlpec, int vyska, int sirka, int farba) {
    /* do matice vykresli ram obdlznika urcitej farby */
    for (int i = 0; i < sirka; i++) {
        a[riadok][stlpec + i] = farba;
        a[riadok + vyska - 1][stlpec + i] = farba;
    }
    for (int i = 0; i < vyska; i++) {
        a[riadok + i][stlpec] = farba;
        a[riadok + i][stlpec + sirka - 1] = farba;
    }
}

void naplnMaticu(int **a, int n, int m) {
    /* do matice vykresli tri obdlzniky. Rozmery musia byt aspon
     * 11 riadkov a 17 stlpcov */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            a[i][j] = 0;
        }
    }
    obdlznik(a, 3, 9, 3, 7, 2);
    obdlznik(a, 1, 3, 8, 9, 1);
    obdlznik(a, 5, 1, 6, 7, 2);
    obdlznik(a, 7, 13, 3, 4, 1);
}

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, 
             int farba, SVGdraw &drawing) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu
     * a[riadok][stlpec] na farbu farba */

    if (a[riadok][stlpec] != farba) {
        int stara_farba = a[riadok][stlpec];
        a[riadok][stlpec] = farba;
        zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "red", drawing);
        drawing.wait(waitTime);
        if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok - 1, stlpec, farba, drawing);
        }
        if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok + 1, stlpec, farba, drawing);
        }
        if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec - 1, farba, drawing);
        }
        if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec + 1, farba, drawing);
        }
        zobrazStvorcek(riadok, stlpec, a[riadok][stlpec], "lightgray", drawing);
        drawing.wait(waitTime);
    }
}


int main(void) {
    int n = 11;
    int m = 17;
    int **a = vytvorMaticu(n, m);
    naplnMaticu(a, n, m);

    SVGdraw drawing(m * stvorcek, n * stvorcek, "vyfarbi1.svg");
    zobrazMaticu(a, n, m, drawing);

    vyfarbi(a, n, m, 2, 1, 3, drawing);

    drawing.finish();
    zmazMaticu(n, m, a);
}

Ukážkový program ostrovy

#include "../SVGdraw.h"
#include <cstdio>

const char * farby[3] = {"white", "green", "black"};
/* velkost stvorceka mapy v pixeloch */
const int stvorcek = 15;

int ** vytvorMaticu(int n, int m) {
    /* vytvor maticu s n riadkami a m stlpcami */
    int **a;
    a = new int *[n];
    for (int i = 0; i < n; i++) {
        a[i] = new int[m];
    }
    return a;
}

void zmazMaticu(int n, int m, int **a) {
    /* uvolni pamat matice s n riadkami a m stlpcami */
    for (int i = 0; i < n; i++) {
        delete[] a[i];
    }
    delete[] a;
}


void nacitajMaticu(FILE *f, int n, int m, int **a) {
    /* matica je vytvorena, velkosti n, m, vyplnime ju cislami zo vstupu */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            fscanf(f,"%d ",&a[i][j]);
        }
    }
}

void zobrazStvorcek(int i, int j, int farba, const char * farbaCiary, SVGdraw &drawing) {
    /* zobraz stvorcek v riadku i a stlpci j */
    drawing.setLineColor(farbaCiary);
    drawing.setFillColor(farby[farba]);
    drawing.drawRectangle(j*stvorcek, i*stvorcek, stvorcek, stvorcek);
}

void zobrazMaticu(int **a, int n, int m, SVGdraw &drawing) {
    /* zobraz vsetky stvorceky matice */
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            zobrazStvorcek(i, j, a[i][j], "lightgray", drawing);
        }
    }
}

void vyfarbi(int **a, int n, int m, int riadok, int stlpec, int farba) {
    /* prefarbi suvislu jednofarebnu oblast obsahujucu
     * a[riadok][stlpec] na farbu farba */

    if (a[riadok][stlpec] != farba) {
        int stara_farba = a[riadok][stlpec];
        a[riadok][stlpec] = farba;
        if (riadok > 0 && a[riadok - 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok - 1, stlpec, farba);
        }
        if (riadok + 1 < n && a[riadok + 1][stlpec] == stara_farba) {
            vyfarbi(a, n, m, riadok + 1, stlpec, farba);
        }
        if (stlpec > 0 && a[riadok][stlpec - 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec - 1, farba);
        }
        if (stlpec + 1 < m && a[riadok][stlpec + 1] == stara_farba) {
            vyfarbi(a, n, m, riadok, stlpec + 1, farba);
        }
    }
}


int main(void) {
    /* nacitaj rozmery matice */
    int n, m;
    FILE *f;
    f=fopen("vstup.txt","r");
    if (!f) return -1;
    
    fscanf(f,"%d %d ",&n,&m);

    /* vytvor a nacitaj maticu */
    int **a = vytvorMaticu(n, m);
    nacitajMaticu(f, n, m, a);

    fclose(f);
    
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            if(a[i][j]>0) a[i][j] = 1;
        }
    }


    SVGdraw drawing(m*stvorcek, n * stvorcek, "ostrovy.svg");
    zobrazMaticu(a, n, m, drawing);

    int ostrovov = 0;
    for(int i=0; i<n; i++) {
        for(int j=0; j<m; j++) {
            if(a[i][j]==1) {
                ostrovov++;
                vyfarbi(a, n, m, i, j, 2);
                drawing.clear();
                zobrazMaticu(a, n, m, drawing);
		drawing.wait(2);
            }
        }
    }

    printf("Pocet ostrovov: %d\n",ostrovov);

    drawing.finish();
    zmazMaticu(n, m, a);
}

Program Sudoku

#include <cstdio>
using namespace std;

/* kazde policko patri do 3 skupin: riadok, stlpec a stvorec */
const int SKUPIN = 3;

/* udaje o jednom policku plochy: suradnice,
 * hodnota (0 ak prazdne, alebo 1..9),
 * a zoznam skupin, do ktorych patri. */
struct policko {
    int riadok, stlpec;
    int hodnota;
    int skupiny[SKUPIN];
};

struct sudoku {
    policko *plocha;  /* pole vsetkych policok plochy */
    bool **obsadene;  /* pre kazdy skupiny ci je dana cifra uz pouzita */
    int pocetPolicok; /* celkovy pocet policok (9*9) */
    int pocetSkupin;  /* celkovy pocet skupin (3*9) */
    int rieseni;      /* pocet najdenych rieseni */
};

void vypis(FILE *f, sudoku &s) {
    /* vypis riesenie sudoku a zvys pocitadlo rieseni */
    s.rieseni++;
    int pozicia = 0;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            fprintf(f," %d",s.plocha[pozicia].hodnota);
            pozicia++;
        }
        fprintf(f,"\n");
    }
    fprintf(f,"\n");
}

int najdiVolne(sudoku &s) {
    /* najdi volne policko na ploche */
    for (int i = 0; i < s.pocetPolicok; i++) {
        if (s.plocha[i].hodnota == 0) return i;
    }
    return -1;
}

bool moze(sudoku &s, int pozicia, int hodnota) {
    /* Mozeme ulozit danu hodnotu na policko s poradovym cislom pozicia?
     * Da sa to, ak ziadna zo skupin tohto policka nema
     * tuto hodnotu uz pouzitu. */
    for (int i = 0; i < SKUPIN; i++) {
        /* cislo i-tej skupiny pre policko */
        int skupina = s.plocha[pozicia].skupiny[i];
        /* ak je uz hodnota obsadena, neda sa pouzit */
        if (s.obsadene[skupina][hodnota]) return false;
    }
    /* vo vsetkych skupinach je hdonota neobsadena */
    return true;
}

void uloz(sudoku &s, int pozicia, int hodnota) {
    /* na policko s poradovym cislom pozicia uloz danu
     * hodnotu. Ak je hodnota > 0, zaregistruj ju
     * tiez ako obsadenu vo vsetkych skupinach,
     * kam policko patri. */
    s.plocha[pozicia].hodnota = hodnota;
    if (hodnota > 0) {
        for (int i = 0; i < SKUPIN; i++) {
            int skupina = s.plocha[pozicia].skupiny[i];
            s.obsadene[skupina][hodnota] = true;
        }
    }
}

void zmaz(sudoku &s, int pozicia) {
    /* hodnotu v policku s pozicia zmen na nulu
     * a povodnu hodnotu odznac v poliach obsadene pre vsetky
     * skupiny tohto policka */
    int hodnota = s.plocha[pozicia].hodnota;
    s.plocha[pozicia].hodnota = 0;
    for (int i = 0; i < SKUPIN; i++) {
        int skupina = s.plocha[pozicia].skupiny[i];
        s.obsadene[skupina][hodnota] = false;
    }
}

void generuj(FILE *f,sudoku &s) {
    /* mame ciastocne vyplnenu plochu sudoku,
     * chceme najst vsetky moznosti, ako ho dovyplnat. */
    int i = najdiVolne(s);
    if (i < 0) {
        vypis(f,s);
    } else {
        for (int x = 1; x <= 9; x++) {
            if (moze(s, i, x)) {
                uloz(s, i, x);
                generuj(f,s);
                zmaz(s, i);
            }
        }
    }
}

void inicializuj(sudoku &s, int **a) {
    /* inicializuj strukturu sudoku na zaklade
     * vstupnej matice s cislami 0..9*/
    s.pocetPolicok = 9 * 9;
    s.pocetSkupin = 3 * 9;
    /* alokujeme polia a oznacime cifry ako neobsadene */
    s.plocha = new policko[s.pocetPolicok];
    s.obsadene = new bool*[s.pocetSkupin];
    for (int i = 0; i < s.pocetSkupin; i++) {
        s.obsadene[i] = new bool[10];
        for (int j = 1; j <= 9; j++) {
            s.obsadene[i][j] = false;
        }
    }
    /* pre kazde policko naplnime jeho strukturu
     * a vyplnime obsadene cifry */
    int pozicia = 0;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            s.plocha[pozicia].riadok = i;
            s.plocha[pozicia].stlpec = j;
            s.plocha[pozicia].skupiny[0] = i;
            s.plocha[pozicia].skupiny[1] = 9 + j;
            s.plocha[pozicia].skupiny[2] = (i / 3)*3 + (j / 3) + 18;
            uloz(s, pozicia, a[i][j]);
            pozicia++;
        }
    }
    /* este sme nenasli ziadne riesenie */
    s.rieseni = 0;
}

void uvolni(sudoku &s) {
    /* alokujeme polia a oznacime cifry ako neobsadene */
    for (int i = 0; i < s.pocetSkupin; i++) {
        delete[] s.obsadene[i];
    }
    delete[] s.obsadene;

    delete[] s.plocha;
}

int main(void) {
    /* alokujeme a nacitame 2D maticu so vstupom */
    int **a = new int *[9];
    for (int i = 0; i < 9; i++) {
        a[i] = new int[9];
    }
    
    FILE *f;
    f=fopen("vstup.txt","r");
    if (!f) return -1;
    
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            fscanf(f,"%d ",&a[i][j]);
        }
    }
    fclose(f);
    
    /* vytvorime struktury pre sudoku */
    sudoku s;
    inicializuj(s, a);

    f=fopen("vystup.txt","w");
    if (!f) return -1;
    
    /* rekurzivne prehladavanie s navratom */
    generuj(f,s);

    fclose(f);
    /* vypis riesenia */
    printf("Pocet rieseni: %d\n",s.rieseni);

    /* este by sme mali odalokovat polia v sudoku */
    for (int i = 0; i < 9; i++) {
        delete[] a[i];
    }
    delete[] a;
    uvolni(s);
    
}

Prednáška 19

Organizačné poznámky

DÚ9 odovzdávajte do pondelka 2.12. 22:00.
PDÚ3 odovzdávajte do pondelka 2.12. 22:00 (pozor zmena!)
Reklama: Nezabudnite v piatok 29.11. ísť na Beániu!

Aritmetické výrazy

Infixový zápis (infixová forma alebo notácia) aritmetického výrazu

bežný zápis používaný v matematike
každý binárny operátor medzi dvoma operandami, s ktorými sa bude vykonávať príslušná operácia
poradie, v akom sa jednotlivé operácie vykonávajú, sa riadi umiestnením zátvoriek a prioritou operácií

Napríklad: (65 – 3*5)/(2 + 3)

Vyhodnocovanie výrazov v infixovej notácii sme ukázali na prednáške 9.

Pre jednoduchosť: úplne uzátvorkovaný výraz, znamienka + a -, čísla, bez medzier, napr. (((12-5)+7)-(6+8))

Pripomeňme si kostru programu:

int vyhodnotVyraz(char str[]){
    if (str[0] != '(') return vyhodnotCislo(str);
    else {
        char s[100];
        int poz, hodnota1, hodnota2;

        poz = najdiZnamienko(str);

        strCopy(str, s, 1, poz-1);      // kopíruj od 1 po pozíciu pred znamienkom (pozícia 0 je '(' )
        hodnota1 = vyhodnotVyraz(s);
        strCopy(str, s, poz+1, strlen(str)-2); // od pozície po znamienku po predposledný znak stringu (posledný znak - strlen()-1 je ')' )
        hodnota2 = vyhodnotVyraz(s);

        switch (str[poz]){
            case '+': return hodnota1+hodnota2;
            case '-': return hodnota1-hodnota2;
        }

        return 0;
    }    
}

int najdiZnamienko(char str[]){
    /*Vieme, ze vyraz je tvaru (Vyraz1 Z Vyraz2)*/
    int poc=0;
    for (int i=1; i<strlen(str)-1; i++){
        if (str[i]=='(') poc++;
        else if (str[i]==')') poc--;
        else if (((str[i]=='+')||(str[i]=='-'))&&(poc==0)) return i;
    }
    return -1;
}

V prípade, že by sme chceli výraz vyhodnocovať bez úplného uzátvorkovania, zmenila by sa hlavne funkcia, ktorá hľadá operand, ktorý potrebujeme vykonať.

Postfixová a prefixovová notácia

Okrem infixovej notácie se môžeme stretnúť s ďalšími formami zápisu aritmetických výrazov.

Postfixová notácia (obrátená poľská notácia) má v zápise výrazu operátor až po oboch operandoch.

Výraz (65 – 3*5)/(2 + 3) by teda v postfixovej forme mal notáciu 65 3 5 * - 2 3 + /

V prefixovej notácii je situácia opačná ako pri postfixovej notácii. Každý operátor stojí pred dvoma operandami, ku ktorým prislúcha.

Výraz (65 – 3*5)/(2 + 3) by v prefixovej forme bol / - 65 * 3 5 + 2 3

Postfixová a prefixová notácia sú na prvý pohľad pre človeka neprehľadné, ale ako uvidíme, dajú sa oveľa jednoduchšie vyhodnocovať. Okrem toho vidíme ešte jednu výhodu - nepotrebujú zátvorky.

Vyhodnocovanie postfixovej formy

Na vyhodnocovanie výrazov v postfixovej forme budeme používať zásobník. Budeme do neho vkladať operandy - teda hodnoty podvýrazov.

Využijeme vlastnosť, že operátor má oba operandy pred sebou. Teda vo chvíli, keď narazíme na operátor, jeho operandy už máme niekde prečítané.
Navyše sú to posledné dve prečítané alebo vypočítané hodnoty.

Pri vyhodnocovaní výrazu prechádzame výraz zľava doprava

Keď narazíme na operand, uložíme ho do zásobníku.
Keď narazíme na operátor, tak vyberieme dva operandy zo zásobníku.
- Ale pozor! Keďže máme zásobník (LIFO), musíme prehodiť poradie operandov oproti tomu, ako sme ich vybrali zo zásobníku
- Napríklad delenie a/b je v postfixovej notácii a b /, teda zo zásobníku najskôr vyberieme deliteľa (b) a ako druhého vyberieme delenca (a), a preto pri vykonávaní operácie musíme prehodiť ich poradie.
Vykonáme operáciu s vybranými operandami a výsledok tejto operácie umiestnime späť do zásobníku.

Tento postup opakujeme, kým nedojdeme na koniec výrazu. V tom okamžiku by sme mali mať na zásobníku jeden prvok a to je výsledok výrazu.

int main(void) {
    stack s;  // vytvor prazdny zasobnik
    init(s);
    char postfix[maxN];  // nacitaj vyraz do retazca
    fgets(postfix, maxN, stdin);

    int i = 0;
    while (postfix[i] != '\0') {
        if (isspace(postfix[i])) { // preskakuj biele znaky
            i++;
        } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu
            push(s, evaluateNumber(postfix, i));
        } else { // binarny operator
            double elem1 = pop(s);
            double elem2 = pop(s);
            switch (postfix[i]) {
                case '+': push(s, elem2 + elem1);
                    break;
                case '-': push(s, elem2 - elem1);
                    break;
                case '*': push(s, elem2 * elem1);
                    break;
                case '/': push(s, elem2 / elem1);
                    break;
            }
            i++;
        }
    }
    printf("%f\n", pop(s));  // na zasobniku mame vysledok
    assert(isEmpty(s));      // teraz uz je zasobnik prazdny 
}

Funkcia evaluateNumber môže vyzerať napríklad takto:

double evaluateNumber(char str[], int &i) {
    /* Z retazca od pozicie i precitaj cislo az po prvy
     * iny znak (medzera, koniec retazca, operator).
     * Cislo i sa nastavi na prvu poziciu, ktora sa neda precitat. */
    double val = 0;
    while (isdigit(str[i])) {
        val = val * 10 + (str[i] - '0');
        i++;
    }
    /* desatinna cast */
    if (str[i] == '.') {
        i++;
        double power = 0.1;
        while (isdigit(str[i])) {
            val += (str[i] - '0') * power;
            power /= 10;
            i++;
        }
    }
    return val;
}

Konverzia infixovej formy na postfixovú

Vidíme, že vyhodnocovanie postfixového výrazu je jednoduché. Väčšinou však pracujeme s infixovou formou zápisu a preto ju potrebujeme nejakým spôsobom prepísať do postfixovej.

Pre jednoduchosť si najskôr ukážeme iba výrazy bez zátvoriek (* a / majú vyššiu prioritu ako + a -). Použijeme zásobník, do ktorého si budeme ukladať zatiaľ nevypísané časti infixovej formuly (teda operátory, ktoré ešte nemajú oba operandy).

Pri vyhodnocovaní prechádzame výrazom zľava doprava:

Ak objavíme operand, prepíšeme ho do postfixového reťazca a ďalej nás už nezaujíma.
Ak narazíme na operátor, pozrieme sa na vrch zásobníka:
- Kým operátor zo zásobníka má väčšiu alebo rovnakú prioritu, tak vyberáme zo zásobníka (a vybrané operátory prepíšeme do postfixového reťazca). Vypisujeme až dokiaľ nenarazíme na operátor s nižšou prioritou (alebo dno).
Po tomto kroku umiestnime aktuálny operátor do zásobníka.
Tento postup opakujeme pokiaľ nenarazíme na koniec výrazu.
- Potom vyberieme operátory zo zásobníka a umiestnime ich na výstup.

Pridanie zátvoriek:

Ľavú zátvorku iba vložíme do zásobníka
Keď narazíme na pravú zátvorku, znamená to, že všetky operátory, ktoré boli v zátvorke, by mali byť už vypísané na výstup. Preto ich vypisujeme, až kým nenarazíme na ľavú zátvorku.

int precedence(char op) {
    if (op == '#' || op == '(') return 0; // specialne pripady, ktore bezne nevyhadzujeme
    if (op == '-' || op == '+') return 1;
    if (op == '*' || op == '/') return 2;
    assert(false); // sem by sme sa nemali dostat    
}

int main(void) {
    char infix[maxN], postfix[maxN];
    fgets(infix, 100, stdin); // nacita aritmeticky vyraz v infixovej forme

    stack s; // vytvor prazdny zasobnik
    init(s);
    push(s, '#'); // specialne dno zasobnika

    int j = 0; /* index do vystupneho retazca */
    for (int i = 0; infix[i] != 0; i++) {
        if (isdigit(infix[i]) || infix[i]=='.') { /* cisla skopirujeme na vystup */
            postfix[j++] = infix[i];
        }
        else if (isspace(infix[i])) { /* biele znaky preskakujeme */
        } else if (infix[i] == '(') { /* zaciatok zatvorky dame na zasobnik */
            push(s, infix[i]);
        } else if (infix[i] == ')') {
            /* koniec zatvorky znamena, ze vypiseme vsetky operatory, 
             * co boli v tej zatvorke (a este nie su vypisane)*/
            char popped = pop(s);
            postfix[j++] = ' ';
            while (popped != '(') {
                postfix[j++] = popped;
                postfix[j++] = ' ';
                popped = pop(s);
            }
        }
        else { /* spracovanie operatora */
            postfix[j++] = ' '; // pridame medzeru
            int p = precedence(infix[i]); // dolezitost prichadzajuceho operatora
            while (precedence(peek(s)) >= p) {
                postfix[j++] = pop(s);
                postfix[j++] = ' ';
            }
            push(s, infix[i]);
        }
    }

    /* vsetko, co na zasobniku ostalo, vypiseme */
    char popped = pop(s);
    postfix[j++] = ' ';
    while (popped != '#') {
        postfix[j++] = popped;
        postfix[j++] = ' ';
        popped = pop(s);
    }

    postfix[j] = '\0';
    printf("Postfix: %s\n", postfix);
}

Program na niekoľkých miestach pridáva medzery (občas zbytočné), aby sa nám operandy nezliali do jedného čísla a vedeli sme ich následne vyhodnocovať.
Nefunguje pre unárne mínus (napr. 2*-3), ktoré treba detekovať a kopírovať na výstup spolu s číslom (a správne spracovávať aj v postfixovej notácii)

Cvičenia:

Ako by ste rozšírili o operáciu umocnenia ^ s ešte vyššou prioritou ako *?
Niektoré časti programu (cykly while) sa trochu opakujú, ako by sa to dalo vyriešiť pomocnou funkciou?
Ako by sme program upravili, aby nikde nedal dve medzery za sebou?

Zhrnutie

Aritmetické výrazy

Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3)
Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3))
Postfixová notácia 65 3 5 * - 2 3 + /
Prefixová notácia / - 65 * 3 5 + 2 3
Prefixová a postfixová notácia nepotrebujú zátvorky
Prevod z infixovej notácie na postfixovú pomocou zásobníka
- Čo si ukladáme do zásobníka?
Vyhodnocovanie postfixovej notácie pomocou zásobníka
- Čo si ukladáme do zásobníka?

Aritmetický výraz ako strom

Ďalšia téma:

uloženie aritmetického výrazu vo forme stromu a práca so stromami všeobecne

Budúci týždeň:

ďalšie príklady stromov v informatike

Strom pre výraz (65 – 3*5)/(2 + 3)

Reprezentácia aritmetického výrazu vo forme stromu

Každý operátor a každé číslo tvorí vrchol stromu
Vrchol pre operátor má pod sebou zavesené menšie stromy pre podvýrazy, ktoré spája
Informatici stromy väčšinou kreslia hore nohami, s koreňom na vrchu
- V našom príklade je koreň vrchol s operátorom /

Dátová štruktúra pre vrcholy stromu

struct node {
    /* vrchol stromu  */
    double val;     /* ciselna hodnota */
    char op;        /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */
    node * left;    /* lavy podvyraz */
    node * right;  /* pravy podvyraz */
};

Ak máme vrchol pre operátor:

left a right sú smerníky na ľavý a pravý podvýraz
znak op je znamienko operátora, napr. '+'
hodnota val je nevyužitá

Ak máme vrchol pre číslo vo výraze:

left a right majú hodnotu NULL (žiadne podvýrazy)
znak op má hodnotu medzera ' '
val obsahuje hodnotu čísla

Jednoduchá ale nie veľmi elegantná reprezentácia

niektoré položky sú nevyužité (val v operátoroch, left a right pri číslach)
budúci semester uvidíme krajšie riešenie pomocou objektov

Vytváranie vrcholov stromu

Nasledujúce dve funkcie vytvoria nový vrchol.

Pre vrchol typu operátor už funkcia dostane smerníky na vrcholy pre podvýrazy

node * createOp(char op, node *left, node *right) {
    /* vytvori novy vrchol stromu s operatorom op
     * a do jeho laveho a praveho podvyrazu ulozi
     * smerniky left a right. */
    node *v = new node;
    v->left = left;
    v->right = right;
    v->op = op;
    return v;
}

node * createNum(double val) {
    /* Vytvori novy vrchol stromu s danou hodnotou,
     * lavy a pravy podvyraz bude prazdny, op bude medzera */
    node *v = new node;
    v->left = NULL;
    v->right = NULL;
    v->op = ' ';
    v->val = val;
    return v;
}

Vytvorme teraz ručne strom pre náš výraz (65 – 3*5)/(2 + 3):

node *v = createOp('/',
            createOp('-', createNum(65),
                          createOp('*', createNum(3), createNum(5))),
            createOp('+', createNum(2), createNum(3)));

Alebo to môžeme rozpísať po krokoch:

node *v65 = createNum(65);
node *v3 = createNum(3);
node *v5 = createNum(5);
node *v2 = createNum(2);
node *v3b = createNum(3);
node *vKrat = createOp('*', v3, v5);
node *vMinus = createOp('-', v65, vKrat);
node *vPlus = createOp('+', v2, v3b);
node *vDeleno = createOp('/', vMinus, vPlus);

Vyhodnocovanie výrazu

double evaluate(node *v) {
    /* vyhodnoti vyraz dany stromom s korenom vo vrchole v */
    assert(v != NULL);

    /* ak je operator medzera, vratime jednoducho hodnotu */
    if (v->op == ' ') {
        return v->val;
    }

    /* rekurzivne vyhodnotime lavy a pravy podvyraz */
    double valLeft = evaluate(v->left);
    double valRight = evaluate(v->right);

    /* Hodnotu laveho a praveho podvyrazu spojime podla typu operatora
     * a vratime. Prikaz break netreba, pouzivame return. */
    switch (v->op) {
        case '+': return valLeft + valRight;
        case '-': return valLeft - valRight;
        case '*': return valLeft * valRight;
        case '/': return valLeft / valRight;
        default: assert(false);
    }
}

Zhrnutie

Aritmetický výraz vieme reprezentovať aj ako strom.
Rekurzívnou funkciou môžeme potom ľahko spočítať jeho hodnotu.
Nabudúce si ukážeme, ako prerobiť postfixovú formu na strom (a tým pádom vieme prerobiť aj infixovú, lebo tú vieme prerobiť na postfixovú).
Ukážeme si tiež, ako výraz reprezentovaný stromom vypísať vo všetkých troch formách.

Terminológia stromov

Strom má vrcholy (nodes, vertices) a tie sú pospájané hranami (edges)
Nás zaujímajú zakorenené stromy, ktoré majú jeden vrchol zvolený ako koreň (root)
Každý iný vrchol okrem koreňa je spojený hranou s jedným otcom (parent) a s niekoľkými (nula alebo viac) synmi (children)
Listy sú vrcholy, ktoré nemajú deti, ostatné vrcholy voláme vnútorné
V binárnom strome má každý vrchol najviac dve deti
Predkovia vrchola sú všetky vrcholy na ceste od neho smerom ku koreňu, teda on sám, jeho otec, otec jeho otca atď, až kým nenarazíme na koreň
Ak x predkom y, tak y je potomkom x
Podstrom s koreňom vo vrchole x tvorí vrchol x a všetci jeho potomkovia
Strom je teda buď prázdny, alebo je tvorený koreňom a dvoma podstromami: ľavým a pravým.

Náš aritmetický strom

Je binárny
V listoch sú čísla, vo vnútorných vrcholoch operácie
Každý vnútorný vrchol má dve deti

Cvičenia 10

Zásobník a rad

Majme zásobník, do ktorého ukladáme dáta typu char. Do nasledujúceho úryvku kódu vložte na tri miesta príkaz cout << pop(s) tak, aby program vypísal text BAC

stack s;
init(s);
push(s, 'A');
push(s, 'B');
push(s, 'C');

Majme dva rady, do ktorých ukladáme dáta typu char. Do nasledujúceho úryvku kódu vložte na vhodné miesta príkazy tak, aby program vypísal text BAC. Môžete použiť len tri typy príkazov, každý aj viackrát:
- cout << dequeue(q1);
- enqueue(q1, dequeue(q2));
- enqueue(q2, dequeue(q1));

queue q1, q2;
init(q1);
init(q2);
enqueue(q1, 'A');
enqueue(q1, 'B');
enqueue(q1, 'C');

Spájané zoznamy

Napíšte funkciu vyhod(linkedList &z), ktorá z jednosmerného spájaného zoznamu vyhodí všetky záznamy, v ktorých má položka data nulovú hodnotu. Pozor, takéto záznamy sa môžu vyskytovať aj na začiatku zoznamu. Vyhodené položky zoznamu treba odalokovať. V prednáške 16 nájdete funkcie na vytvorenie a vypísanie zoznamu, ktoré môžete použiť na testovanie vašej funkcie.

Napíšte funkciu kopiruj(linkedList &kam, linkedList &odkial), ktorá vytvorí kópiu zoznamu odkial a uloží ju do zoznamu kam (zoznam kam je na začiatku prázdny).

Napíšte funkciu zip(linkedList &z1, linkedList &z2, linkedList &z3), ktorá vyvorí z dvoch zoznamov ich "zips" - vo výslednom zozname sa budú postupne striedať prvky z prvého a druhého zoznamu. Pokiaľ má jeden zoznam viac prvkov ako ten druhý, tak jeho zvyšné prvky budú na konci zoznamu.

 zip({1,2,3}, {10,11,12,13,14}) = {1,10,2,11,3,12,13,14}

Napíšte funkciu reverse(linkedList &z), ktorá otočí poradie prvkov v zozname (jednosmernom spájanom).

Prednáška 20

Organizačné poznámky

Domáce úlohy:

Dnes termín DÚ9 a PDÚ3.
DÚ10 do piatka, bonus do ďalšieho pondelka
PDÚ4 zverejníme čoskoro, termín bude 20.12.
Ešte bude DÚ11 s termínom 20.12.

Budúci piatok 13.12. o 14:00 v posluchárni B písomka

Na stránke tento týždeň zverejníme ukážkové príklady na písomku a skúšku
Na písomke aj skúške povolený ťahák v rozsahu jedného listu formátu A4 s ľubovoľným obsahom na oboch stranách

Prednášky:

dnes viac o stromoch, dokončíme aritmetické výrazy
zajtra binárne vyhľadávacie stromy
budúci pondelok lexikografické stromy
budúci utorok opakovanie, príprava na písomku a skúšku
posledný pondelok slovník, hešovanie
posledný utorok nepreberané črty jazykov C a C++

Opakovanie

Aritmetické výrazy

Bežná infixová notácia, napr. (65 – 3*5)/(2 + 3)
Úplne uzátvorkovaná, napr. ((65 – (3*5))/(2 + 3))
Postfixová notácia 65 3 5 * - 2 3 + /
Prefixová notácia / - 65 * 3 5 + 2 3
Prefixová a postfixová notácia nepotrebujú zátvorky
Prevod z infixovej notácie na postfixovú pomocou zásobníka
Vyhodnocovanie postfixovej notácie pomocou zásobníka

Strom pre výraz (65 – 3*5)/(2 + 3)

Aritmetické výrazy ako stromy

Každý operátor a každé číslo tvorí vrchol stromu
Vrchol pre operátor má pod sebou zavesené podstromy pre podvýrazy, ktoré spája

struct node { /* vrchol stromu  */
    double val;     /* ciselna hodnota */
    char op;        /* operator '+', '-', '*', '/', 
                     * alebo ' ' ak ide o hodnotu */
    node * left;    /* lavy podvyraz alebo NULL */
    node * right;   /* pravy podvyraz alebo NULL */
};

node * createOp(char op, node *left, node *right) {
    /* vytvori novy vrchol stromu s operatorom op
     * a do jeho laveho a praveho podvyrazu ulozi
     * smerniky left a right. */
    node *v = new node;
    v->left = left;
    v->right = right;
    v->op = op;
    return v;
}

node * createNum(double val) {
    /* Vytvori novy vrchol stromu s danou hodnotou,
     * lavy a pravy podvyraz bude prazdny, op bude medzera */
    node *v = new node;
    v->left = NULL;
    v->right = NULL;
    v->op = ' ';
    v->val = val;
    return v;
}

Vytvorenie stromu z postfixového výrazu

Pripomeňme si kód na vyhodnocovanie postfixového výrazu:

typedef double dataType;

double evaluatePostfix(char postfix[]) {
    stack s;
    init(s);
    int i = 0;
    while (postfix[i] != '\0') {
        if (isspace(postfix[i])) { // preskakuj biele znaky
            i++;
        } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu
            push(s, evaluateNumber(postfix, i));
        } else { // binarny operator
            double elem1 = pop(s);
            double elem2 = pop(s);
            switch (postfix[i]) {
                case '+': push(s, elem2 + elem1);
                    break;
                case '-': push(s, elem2 - elem1);
                    break;
                case '*': push(s, elem2 * elem1);
                    break;
                case '/': push(s, elem2 / elem1);
                    break;
            }
            i++;
        }
    }
    return pop(s);
}

Do zásobníka si ukladáme čísla - medzivýsledky už vyhodnotených podvýrazov.
Pri tvorbe stromu si tam namiesto toho budeme ukladať už vytvorené podstromy.

typedef node * dataType;

node *parsePostfix(char *postfix) {
    stack s;
    init(s);

    int i = 0;
    while (postfix[i] != '\0') {
        if (isspace(postfix[i])) { // preskakuj biele znaky
            i++;
        } else if (isdigit(postfix[i]) || postfix[i]=='.') { // spracuj jedno cislo zo vstupu
            double val = evaluateNumber(postfix, i);
            push(s, createNum(val));
        } else { // binarny operator
            node * elem1 = pop(s);
            node * elem2 = pop(s);
            node * v = createOp(postfix[i], elem2, elem1);
            push(s, v);
            i++;
        }
    }
    return pop(s);
}

Dátová štruktúra pre binárne stromy

Dátovú štruktúru pre vrcholy binárnych stromov môžeme zovšeobecniť a použiť v nej nejaký všeobecný typ dataType, podobne ako pri zásobníku. Spravíme si tiež všeobecnú funkciu na vytvorenie nového vrcholu, ktorá dostane smerníky na podstromy.

struct node {
    /* vrchol stromu  */
    dataType data;
    node * left;  /* lavy podstrom */
    node * right; /* pravy podstrom */
};

node * createNode(dataType data, node *left, node *right) {
    node *v = new node;
    v->data = data;
    v->left = left;
    v->right = right;
    return v;
}

Uvažujme strom, v ktorom každý vrchol obsahuje jeden znak. Ako bude vyzerať tento strom?

node *v = createNode('A',
            createNode('B', createNode('C', NULL, NULL),
                            createNode('D', NULL, NULL)),
            createNode('E', NULL, createNode('F', NULL, NULL)));

Použitie pre aritmetické výrazy

Ak by sme takýto všeobecný strom chceli použiť na aritmetické výrazy, definujeme si dataType ako štruktúru s dvoma položkami op a val, ktoré vo vrcholoch potrebujeme. Funkcie createOp a createNum vieme napísať pomocou createNode.

struct dataType {
    double val;     /* ciselna hodnota */
    char op;     /* operator '+', '-', *', '/', alebo ' ' ak ide o hodnotu */
};

node * createOp(char op, node *left, node *right) {
    dataType d;
    d.op = op;
    return createNode(d, left, right);
}

node * createNum(double val) {
    dataType d;
    d.op = ' ';
    d.val = val;
    return createNode(d, NULL, NULL);
}

Ak teraz máme premennú v ako smerník na nejaký vrchol stromu, namiesto v->op budeme písať v->data.op.

Prehľadávanie stromov

Často potrebujeme prejsť celý strom a spracovať dáta vo všetkých vrcholoch.
Napríklad chceme vypísať hodnotu v každom vrchole
Opäť použijeme rekurziu, voláme na ľavý a pravý podstrom.

void print(dataType &d) {
    cout << d;
}

void preorder(node *v) {
    if (v == NULL) return;
    print(v->data);
    preorder(v->left);
    preorder(v->right);
}

Pre príklad stromu uvedeného vyššie vypíše ABCDEF
Takéto poradie sa volá preorder, lebo najprv vypíšeme (spracujeme) dáta vo vrchole, až potom v jeho podstromoch.
Dáta vo vrchole môžeme vypísať aj po navštívení oboch podstromov, takéto poradie nazývame postorder.
- Pre náš strom CDBFEA
Alebo ich môžeme vypísať medzi navštívením ľavého a pravého vrcholu, takéto poradie nazývame inorder.
- Pre náš strom CBDAEF

void postorder(node *v) {
    if (v == NULL) return;
    postorder(v->left);
    postorder(v->right);
    print(v->data);
}

void inorder(node *v) {
    if (v == NULL) return;
    inorder(v->left);
    print(v->data);
    inorder(v->right);
}

Vypisovanie aritmetických výrazov

Preorder vypisovanie vypíše výraz v prefixovej notácii / - 65 * 3 5 + 2 3
Postorder vypisovanie vypíše výraz v postfixovej notácii 65 3 5 * - 2 3 + /

void print(dataType &d) {
    /* funkcia na tlac jedneho vrcholu pouzita v preorder a postorder */
    if(d.op == ' ') {
      cout << ' ' << d.val;
    }
    else {
        cout << ' ' << d.op;
    }
}

Inorder vypisovanie nevypíše výraz v infixovej notácii, chýbajú zátvorky 65 - 3 * 5 / 2 + 3
- Chceme úplne uzátvorkovaný výraz, napr. ( ( 65 - ( 3 * 5 ) ) / ( 2 + 3 ) )

void infix(node *v) {
    /* funkcia na tlac vyrazu v infixovej notacii */
    if(v->data.op == ' ') {
        cout << ' ' << v->data.val;
    }
    else {
        cout << " (";
        infix(v->left);
        cout << " " << v->data.op;
        infix(v->right);
        cout << " )";
    }
}

Ako by sme vynechali zbytočné zátvorky?

Jednoduchá práca so stromami

Výška (hĺbka) stromu

Hĺbka vrcholu v strome je jeho vzdialenosť od koreňa. T.j. koreň má hĺbku 0, jeho synovia hĺbku 1 atď.
Výška stromu (niekedy nazývaná hĺbka stromu) je maximum z hĺbok jeho vrcholov
- Ak máme strom s jedným vrcholom, výška je 0
- Inak spočítame výšku ľavého a pravého podstromu
- Ku každej pripočítame 1, lebo pridávame hranu k otcovi
- Aby to fungovalo aj pre prázdne podstromy, dodefinujeme výšku prázdneho podstromu na -1

 int height(node *v) {
    /* Vrat vysku stromu s korenom v.
     * Ak v je NULL, vrati -1. */
    if (v == NULL) return -1;
    int left = height(v->left);
    int right = height(v->right);
    /* vrat max(left, right)+1 */
    if (left >= right) return left + 1;
    else return right + 1;
}

Ak máme binárny strom s n vrcholmi, aká môže byť jeho minimálna a maximálna výška?

Výška stromu s n vrcholmi je najviac n-1, ak sú všetky navešané jeden pod druhý, t.j. každý okrem posledného má jedného syna
Strom s výškou h má najviac Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^{h+1}-1} vrcholov
- Dá sa dokázať indukciou vzhľadom na h
Takže vieme, že Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle n\le 2^{h+1}-1} .
Vyjadríme h: Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle h\ge \log_2(n+1)-1}
Takže dostávame Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle \log_2(n+1)-1 \le h \le n-1}

Úplný binárny strom

Strom, ktorý má pri určitej hĺbke h maximálny počet vrcholov, t.j. Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle 2^{h+1}-1} sa nazýva úplny binárny strom.
Chceli by sme taký strom vytvoriť.

Použijeme funkciu createNode na vytvorenie jedného vrcholu:

node * createNode(dataType data, node *left, node *right) {
    node *v = new node;
    v->data = data;
    v->left = left;
    v->right = right;
    return v;
}

Rekurzívne tvoríme väčšie stromy z menších.
Globálna premenná count priradí vrcholom do dátovej položky poradové číslo.

node* createTree(int height) {
    if (height == -1) return NULL;
    node* u = createNode(count++, NULL, NULL);
    u->left = createTree(height - 1);
    u->right = createTree(height - 1);
    return u;
}

Uvoľňovanie stromu

Pri ukončení práce by sme mali uvoľniť pamäť, ktorú sme potrebovali na strom.

void destroyTree(node* v){
  if(v!=NULL){
    destroyTree(v->left);
    destroyTree(v->right);
    delete v;
  }
}

Cvičenia

Napíšte funkciu, ktorá každému uzlu prirobí smerník na rodiča do položky parent typu node *
Vo výrazoch by sme mohli mať aj premenné, potom za ne dosadzovať hodnoty alebo celé podvýrazy
- Ako by sme premenné reprezentovali v štruktúre dataType?
Predstavme si, že v preorder poradí namiesto dát vypíšeme počet detí daného vrcholu. Napríklad pre náš strom so znakmi to bude 2 2 0 0 1 0 (preorder poradie je A B C D E F, vrcholy A a B majú po dve deti, vrcholy C a D majú 0 detí, vrchol E má jedno dieťa a vrchol F 0 detí). Ako z takejto postupnosti zostavíme strom? Je jednoznačne daný? Skúste si nakresliť strom pre postupnosť 2 0 2 1 2 0 0 2 0 0.

Prednáška 21

Organizačné poznámky

DÚ10 odovzdávajte do piatka 6.12. 22:00 a jej bonusovú časť do pondelka 9.12. 22:00
Písomný test
- Riadny termín piatok 13.12. o 14:00 v posluchárni B
- Opravný/náhradný termín pondelok 13.1. o 14:00 v akváriu M-VII

Termíny skúšok vždy o 9:00:
- 9.1. M217, M218
- 22.1. H6
- 5.2. H6 (opravný termín)
- 12.2. M217, M218 (2. opravný termín)

Na termín skúšky sa zapisujte v systéme AIS. Ústna časť skúšky sa koná v poobedňajších hodinách ten istý deň.

Opakovanie: binárne stromy

V každom vrchole máme uložené nejaké dáta a smerník na ľavého a pravého syna.

struct node {
    /* vrchol stromu  */
    dataType data;
    node * left;  /* lavy syn */
    node * right; /* pravy syn */
};

Príklad využitia: reprezentácia aritmetických výrazov
Na prechádzanie všetkých vrcholov sa hodí rekurzia
- videli sme preorder, inorder, postorder poradie vypisovania

void inorder(node *v) {
    if (v == NULL) return;
    inorder(v->left);
    print(v->data);
    inorder(v->right);
}

Hľadanie prvku v strome

Chceme zistiť, či sa v strome nachádza určitá hodnota, alebo spočítať, koľkokrát sa tam nachádza.
Môže byť hocikde, preto musíme prejsť rekurzívne všetky vrcholy stromu

int count(node *v, dataType x) {
    /* Vrat pocet vyskytov hodnoty x v strome s korenom v. */
    if (v == NULL) return 0;
    int add = 0;
    if (v->data == x) add = 1;
    return count(v->left, x) + count(v->right, x) + add;
}

Reprezentácia množiny

Často potrebujeme reprezentovať množinu prvkov (čísiel). Keďže sa jedná o množinu, každý z prvkov sa v nej nachádza maximálne raz. Ak by sme množinu chápali ako ADT očakávali by sme operácie init, insert a find. Okrem toho sa nám môže hodiť aj funkcia isEmpty, ktorá nám povie, či je množina prázdna. Operáciu remove, ktorá odstráni prvok z množiny sa nie vždy v ADT množina implementuje.

/* inicializuje prázdnu množinu */
void init(set &s);

/* prida prvok item do množiny */
void insert(set &s, dataType item); 

/* zistí, či sa v množine nachádza prvok item, ale necha ho v množine */
bool find(set &s, dataType item);

/* vypíše prvky množiny */
void print(set s);

Ako dataType môžeme využiť typy premenných, kde vieme určiť rovnosť pomocou =, prípadne ich aj porovnávať pomocou < (int, double, ...). Ešte potenciálne potrebujeme uvoľniť pamäť nejakou ďalšou funkciou, napr. destroy, prípadne pre zložitejšie dataType createItem, destroyItem a sposob ich porovnania.

Využitie ADT množina

Ak máme implementovaný ADT množina, môžeme pomocou neho z postupnosti čísel odstrániť duplikáty. Je zrejmé, že ak sa prvok v množine nachádza, nepotrebujeme ho pridávať, lebo už je duplikátom niektorého čísla. Naopak, ak sa číslo zatiaľ nenachádza v množine, môžeme si ho pridať a uložiť 9jeho prípadné duplikáty už nepridáme.

typedef int dataType;

void removeDuplicates(){
    set s;
    dataType x;
    init(s);
    while (!feof(stdin)){
      cin>>x;
      if (!find(s,x)) insert(s,x);
    }
    print(s);
}

Implementácia ADT množina pomocou neutriedeného poľa

Ak budeme implementovať množinu pomocou poľa, štruktúru množiny môžeme reprezentovať nasledovne:

struct set {
    dataType* a;
    int count;
};

Potom pri inicializácii potrebujeme alokovať miesta pre pole a.
Počet prvkov množiny nastavíme na 0.

/* inicializuje prázdnu množinu */
void init(set &s){
    s.a=new dataType[Nmax];
    s.count=0;
}

Vypísanie prvkov množiny je vlastne vypísanie celého poľa.

void print(set s){
    cout<<"{";
    for (int i=0; i<s.count-1; i++){
        cout<<s.a[i]<<", ";
    }
    if (s.count>0) cout<<s.a[s.count-1]<<"}"<<endl;
    else cout <<"}"<<endl;
}

V prípade, že do poľa sa rozhodneme ukladať prvky v neutriedenom poradí, môžeme pridávanie spraviť jednoducho umiestnením nového prvku na koniec.
Pre vyhľadanie prvku potom potrebujeme prejsť všetky prvky a zistiť, či nie je s niektorým z nich rovný (preto potrebujeme dataType, ktorý vieme porovnávať pomocou =).

/* zistí, či sa v množine nachádza prvok item, ale necha ho v množine */
bool find(set s, dataType item){
    for (int i=0; i<s.count; i++){
        if (s.a[i]==item) return true;
    }
    return false;
}

/* prida prvok item do množiny */
void insert(set &s, dataType item){
    /* predpokladáme, že prvok tam ešte nie je. */
    assert(find(s,item)==false);  
    /* druhou možnosťou je v prípade find(s,item)==true ukončiť vkladanie */
    s.a[s.count]=item;
    s.count++;
}

Implementácia ADT množina pomocou utriedeného poľa

Na prednáške 7 sme si ukázali, že v prípade, že je pole utriedené, má vyhľadávanie v ňom menšiu časovú zložitosť.

Budeme predpokladať, že vkladanie zabezpečí, aby pole ostalo usporiadané. Ako potom vyhľadávať prvok?
- Prvok sa v množine nachádza, ak ho nájdeme v poli a pomocou binárneho vyhľadávania

/*Binárne vyhľadávanie prvku item v poli a (od indexu l po index r)*/
bool binSearch(dataType *a, dataType item, int l, int r){
    if (l>r) return false; 
    int m=(l+r)/2;
    if (a[m]==item) return true;
    if (a[m]>item)  return binSearch(a,item,l,m-1);
    else return binSearch(a,item,m+1,r);
}

/* zistí, či sa v množine nachádza prvok item, ale necha ho v množine */
bool findSorted(set s, dataType item){
    return binSearch(s.a,item,0,s.count-1);
}

Pri vkladaní do utriedeného poľa potrebujeme nájsť miesto, kam prvok vlastne máme vložiť. Ak patrí na miesto index, potom všetky

prvky na indexoch index..count-1 potrebujeme posunúť dozadu.

Ako však zistíme, kam prvok patrí? Patrí tam, kde by sme ho našli pri binárnom vyhľadávaní. Preto binárne vyhľadávanie upravíme tak, aby nám informáciu, kde skončil vyhľadávanie odovzdal v parametri.

/*Binárne vyhľadávanie prvku item v poli a (od indexu l po index r). Miesto nájdenia alebo očakávaného nájdenia je v premennej index.*/
bool binSearch(dataType* a, dataType item, int l, int r, int &index){
    if (l>r) { index=l; return false; }
    int m=(l+r)/2;
    if (a[m]==item) {index=m; return true;}
    if (a[m]>item) { return binSearch(a,item,l,m-1,index);}
    else { return binSearch(a,item,m+1,r,index);}
}

/* prida prvok item do množiny */
void insert(set &s, dataType item){
    int index;
    /* predpokladáme, že prvok tam ešte nie je. */
    assert(binSearch(s.a,item,0,s.count-1,index)==false);
    /* druhou možnosťou je v prípade binSearch(s.a,item,s.count-1,index)==true ukončiť vkladanie */
    
    for (int i=s.count-1; i>=index; i--){
        s.a[i+1]=s.a[i];
    }
    s.a[index]=item;
    s.count++;
}

Implementácia ADT množina pomocou spájaných zoznamov s (ne)utriedenými prvkami

ADT množina môžeme implementovať aj pomocou spájaných zoznamov. V nich binárne vyhľadávanie samozrejme nefunguje a preto nemá zmysel udržiavať ich usporiadané.

Vkladať môžeme na začiatok zoznamu
Pri vyhľadávaní prvku prejdeme celý spájaný zoznam
Všetky funkcie sú vysvetlené a implementované v Prednáške 16.

Zhrnutie zložitostí jednotlivých operácii

Časové zložitosti jednotlivých implementácií:

Usporiadané pole: Find - O(log n), Insert - O(n)
Neusporiadané pole: Find - O(n), Insert - O(1)
Neusporiadaný spájaný zoznam: Find - O(n), Insert - O(1)

Binárne vyhľadávacie stromy

Binárne vyhľadávacie stromy sú usporiadané tak, aby sme vedli pomerne rýchlo vyhľadať prvok s určitou hodnotou
V každom vrchole máme položku s dátami (data typu dataType)
Pre každý vrchol v stromu platí:
- Každý vrchol u v ľavom podstrome v má hodnotu data menšiu ako vrchol v
- Každý vrchol u v pravom podstrome v má hodnotu data väčšiu ako vrchol v
Z toho vyplýva, že ak vypíšeme strom v inorder poradí, dostaneme prvky usporiadané
Pre danú množinu kľúčov existuje veľa vyhľadávacích stromov

Cvičenie: nájdite všetky binárne vyhľadávacie stromy pre množinu kľúčov {1,2,3}

Definícia dátových štruktúr

V každom vrchole data typu dataType, ktoré vieme porovnávať znamienkom < (napr. int, double, ...)
V každom vrchole si pamätáme aj smerník na otca (ten má hodnotu NULL v koreni)
Strom je potom jednoducho smerník na koreň a inicializujeme ho na NULL.

struct node {
    /* vrchol binarneho vyhladavacieho stromu  */
    dataType data; /* hodnota */
    node * parent;  /* otec vrchola */
    node * left;    /* lavy syn */
    node * right;   /* pravy syn */
};

struct binarySearchTree {
    node *root;  /* koren stromu, NULL pre prazdny strom */
};

void init(binarySearchTree &t) {
    /* inicializuje prazdny binarny vyhladavaci strom */
    t.root = NULL;
}

Pre binárne vyhľadávacie stromy si ukážeme hľadanie, pridávanie a uberanie vrcholov
Ktorý abstraktný dátový typ vám tieto operácie pripomínajú?

Hľadanie vo vyhľadávacom strome

Porovnáme hľadané dáta s dátami v koreni
- Ak sa rovnajú, končíme (našli sme, čo hľadáme)
- Ak je hľadaná hodnota menšia ako dáta v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom
V príslušnom podstrome sa rozhodujeme podľa tých istých pravidiel
Keď narazíme na prázdny podstrom, dáta sa v strome nenachádzajú
Dá sa zapísať rekurzívne alebo cyklom, lebo vždy ideme iba do jedného podstromu

node * findNode(node *root, dataType data) {
    /* V binarnom vyhladavacom strom s korenom root najdi a vrat
     * vrchol s hodnotou data a ak neexistuje, vrat NULL. */
    node * v = root;
    while (v != NULL && v->data != data) {
        if (data < v->data) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
    return v;
}

/* rekurzivna verzia */
node * findNodeR(node *root, dataType data) {
    /* V binarnom vyhladavacom strom s korenom root najdi a vrat
     * vrchol s hodnotou data a ak neexistuje, vrat NULL. */
    if (root == NULL || root->data == data) {  
        return root;
    } else if (data < root->data) {
        return findNodeR(root->left, data);
    } else {
        return findNodeR(root->right, data);
    }
}

Čas výpočtu je v najhoršom prípade úmerný výške stromu

Pre užívateľa rekuziu obalíme do pomocnej funkcie, ktorá vráti true ak sa daná hodnota v strome vyskytuje a false inak

bool find(binarySearchTree &t, dataType data) {
  return findNode(t.root, data) != NULL;
}

Vkladanie prvku do vyhľadávacieho stromu

Predpokladáme, že prvok v strome nie je.
Putujeme po strome podobne ako po vyhľadávaní prvku, až kým nenarazíme na nulový smerník.
- Na tomto mieste by mal byť nový prvok, takže ho tam pridáme ako nový list
Použijeme rozšírenú verziu findNode, ktorá vráti miesto, kam by mal prvok patriť, aj jeho otca.

node * createLeaf(dataType data, node * parent) {
    /* vytvor novy vrchol s danym kľúčom, obe deti nastav na NULL */
    node *v = new node;
    v->data = data;
    v->left = NULL;
    v->right = NULL;
    v->parent = parent;
    return v;
}

void findNode(node *root, dataType data, node *&v, node *&parent) {
    /* Do v uloz smernik na vrchol s hodnotou data alebo NULL ak neexistuje.
     * Do parent uloz otca v, NULL ak neexistuje a ak data nie je v strome
     * tak smernik na vrchol, ktory by mal byt otcom pre vrchol
     * s hodnotou data. */
    parent = NULL;
    v = root;
    while (v != NULL && v->data != data) {
        parent = v;
        if (data < v->data) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
}

void insert(binarySearchTree &t, dataType data) {
    /* Do stromu t vlozi vrchol s hodnotou data na spravne miesto.
     * Predpokladame, ze takyto kluc este v strome nie je. */
    if (t.root == NULL) {
        /* prazdny strom - treba vytvorit koren */
        t.root = createLeaf(data, NULL);
    } else {
        node *v;
        node *parent;
        findNode(t.root, data, v, parent);
        /* parent je teraz vrchol, ktoreho syn ma byt novy vrchol */
        assert(v == NULL && parent != NULL);
        /* zisti, ci mame byt lave alebo prave dieta otca */
        if (data < parent->data) {
            assert(parent->left == NULL);
            parent->left = createLeaf(data, parent);
        } else {
            assert(parent->right == NULL);
            parent->right = createLeaf(data, parent);
        }
    }
}

Čas vkladania je tiež v najhoršom prípade úmerný hĺbke stromu.

Príklad: ako bude vyzerať strom po nasledujúcej postupnosti operácií?

    binarySearchTree t;
    init(t);
    insert(t, 2);
    insert(t, 5);
    insert(t, 3);
    insert(t, 10);
    insert(t, 7);

Odbočka: minimum a nasledovník

Spravíme si dve funkcie, ktoré sa nám zídu pri mazaní prvku, ale môžu sa zísť aj inokedy.

Prvá funkcia nájde vo vyhľadávacom strome minimum.
- Všetky prvky menšie ako koreň sú v ľavom podstrome, bude tam zrejme aj minimum.
- Tá istá úvaha platí pre koreň ľavého podstromu.
- Ideme teda doľava kým sa dá, posledný vrchol vrátime (list alebo vrchol s pravým synom).
- Dá sa tiež pekne napísať rekurzívne.

node *minimumNode(node *v) {
    /* vrati vrchol s minimalnou hodnotou data vo vyhladavacom strome
     * s korenom v */
    assert(v != NULL);
    while (v->left != NULL) {
        v = v->left;
    }
    return v;
}

Druhá funkcia nájde vrchol, ktorý v utriedenom poradí nasleduje za daným vrcholom v.

Ak má v pravého syna, nasledovník bude v pravom podstrome, konkrétne vrchol s minimálnou hodnotou data v tomto podstrome
V opačnom prípade to môže byť rodič, ak v je jeho ľavý syn
Ak je pravý syn, môže to byť prarodič, ak je rodič jeho ľavý syn, atď
Nájdeme teda prvého predka, do ktorého ľavého podstromu patrí v a ten je hľadaný nasledovník

node *successorNode(node *v) {
    /* vrati vrchol, ktorý v utriedenom poradi nasleduje za vrcholom v,
     * alebo NULL ak taky vrchol nie je */
    assert(v != NULL);
    if (v->right != NULL) {
        return minimumNode(v->right);
    }
    while (v->parent != NULL && v == v->parent->right) {
        v = v->parent;
    }
    return v->parent;
}

Mazanie prvkov z vyhľadávacieho stromu

Nájdeme mazaný vrchol v podľa hodnoty data obvyklým spôsobom
Ak je v list, jednoducho ho zmažeme
Ak má v jedno dieťa, toto dieťa prevesíme priamo pod otca v a v zmažeme
Ak má v dve deti, nájdeme nasledovníka v, t.j. minimum v pravom podstrome v.
Tento nasledovník nemá ľavé dieťa, vieme ho teda zmazať.
Jeho údaje presunieme do vrcholu v.
Tiež treba dať pozor na mazanie koreňa.

void remove(binarySearchTree &t, dataType data) {
    /* Zmaze hodnotu data zo stromu t.
     * Predpokladame, ze tam taky kluc je. */

    /* Najdi vrchol s klucom */
    node *v = findNode(t.root, data);
    assert(v != NULL && v->data == data);
    /* najdi vrchol rm s jednym synom child,
     * ktory vyhodime. */    
    node *rm, *child;
    if (v->left == NULL || v->right == NULL) rm = v;
    else rm = successorNode(v);
    assert(rm->left == NULL || rm->right == NULL);
    if (rm->left != NULL) child = rm->left;
    else child = rm->right;

    /* preves syna priamo pod otca rm */
    if (child != NULL) child->parent = rm->parent;
    if (rm->parent == NULL) t.root = child;
    else {
        /* ak rm nie je koren, jeho otcovi zaves child */
        node *parent = rm->parent;
        assert(rm == parent->left || rm == parent->right);
        if (rm == parent->left) parent->left = child;
        else parent->right = child;
    }
    /* ak rm nema mazanu hodnotu data, prekopiruj data z rm do v*/
    if (rm != v) {
        v->data = rm->data;
    }
    delete rm;
}

Zdrojový kód programu s binárnymi vyhľadávacími stromami

Zdrojový kód programu s binárnymi vyhľadávacími stromami

Zhrnutie

Binárny vyhladávací strom je binárny strom, v ktorom platí:

Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome.
Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome.
Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy.

Hodí sa na implementáciu operácií find, remove, insert

Pri hľadaní putujeme od koreňa dole a vždy vieme, či máme pokračovať vľavo alebo vpravo

podobá sa to teda na binárne vyhľadávanie

Zložitosť operácií závisí od výšky stromu. Tá je

V najhoršom prípade O(n)
V priemernom prípade O(log n)

Find, Insert, Delete:

Najlepší prípad O(1)
Najhorší prípad O(height(T))=O(n)
Priemerný prípad O(height(T))=O(log n)

Na druháckom predmete Algoritmy a dátové štruktúry si ukážete obmeny vyhľadávacích stromov, ktoré majú zložisť O(log n) aj v najhoršom prípade

Pre porovnanie jednoduché implementácie množiny, najhoršie aj priemerné prípady:

Usporiadané pole: Find - O(log n), Insert - O(n), Delete - O(n)
Neusporiadané pole: Find - O(n), Insert - O(1), Delete - O(n)
Neusporiadaný spájaný zoznam: Find - O(n), Insert - O(1), Delete - O(n)

Cvičenia 11

Vyfarbovanie

Na prednáške 18 sme mali program, ktorý počítal počet ostrovov na mape. Upravte ho tak, aby našiel ostrov s najväčšou plochou a vyfarbil ho inou farbou ako ostatné ostrovy.
- Upravte funkciu vyfarbi tak, aby vracala celé číslo udávajúce počet políčok, ktoré prefarbila. Tým zistíte plochu jednotlivých ostrovov.

Zátvorky

Do programu na kontrolu správne uzátvorkovaných výrazov z prednášky 17 dopíšte informatívne oznamy pre užívateľa, ktoré mu povedia, zátvorka na ktorom mieste v reťazci nemá ľavý pár alebo na ktorom mieste má ľavý pár iného typu ako pravý alebo koľko ľavých zátvoriek zostalo na konci neuzavretých. Po prvej takejto chybe už ďalšie nevypisujte.

Stromy pre aritmetické výrazy

Uvažujte binárne stromy pre aritmetické výrazy, v ktorých máme aj premennú x. Tá sa spozná podľa toho, že v položke op je uložený znak 'x' (položka val sa v takýchto vrcholoch nepoužíva).
- Napíšte funkciu, ktorá dostane nezáporné celé číslo n a zostaví strom, ktorý reprezentuje Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^n} , pričom použije len vrcholy pre premennú x a pre násobenie.
- Modifikujte funkciu evaluate z prednášky 19 tak, aby pracovala aj pre výrazy s premennou x, pričom hodnotu tejto premennej dostane ako parameter, t.j. hlavička bude double evaluate(node *v, double x). Overte, že ak tútu funkciu spustíte pre váš strom zodpovedajúci Syntaktická analýza (parsing) neúspešná (MathML (experimentálne): Neplatná odpověď („Math extension cannot connect to Restbase.“) od serveru „https://wikimedia.org/api/rest_v1/“:): {\displaystyle x^n} , dostanete správny výsledok.

Deque

Uvažujme abstraktný dátový typ deque, ktorý je kombináciou radu a zásobníka. Dovoľuje
- pridávať na jeden aj druhý koniec postupnosti (funkcie addFirst, addLast)
- mazať na jednom aj druhom konci postupnosti (funkcie removeFirst a removeLast), pričom zmazaný prvok vráti
- pozrieť sa na prvý a posledný prvok bez toho aby sa zmazal (funkcie getFirst a getLast)
- pomocné operácie isEmpty, init a destroy
Ako by ste pomocou deque implementovali zásobník a ako rad? (t.j. ktoré operácie sú ekvivalentné push, pop, resp. enqueue a dequeue)?
Prepíšte implementáciu radu pomocou poľa tak, aby poskytovala všetky operácie pre deque. Nezabudnite pomocou príkazu assert skontrolovať, že dátová štruktúra nie je preplnená pri pridávaní, ale ani prázdna pri vyberaní a vracaní prvku.

Prednáška 22

Bonus k DÚ10 odovzdávajte do dnes 22:00
- DÚ11 zverejníme tento týždeň, odovzávajte do piatku 20.12. 22:00
- PDÚ4 tiež do piatku 20.12. 22:00
Písomný test tento piatok 13.12. o 14:00 v posluchárni B
Termíny skúšok na stránke, zapisujte sa cez AIS
Zajtrajšia prednáška: opakovanie, zhrnutie, príprava na písomku a skúšku
- Pozrite si ukážkové príklady, pripravte si otázky
Budúci pondelok prednáška nebude
Budúci utorok posledná prednáška:
- hashovanie (môže byť na opravnom teste alebo na skúške)
- nepreberané črty jazykov C a C++ (nebudeme skúšať, ale môžete použiť teraz alebo na ďalších predmetoch)

Opakovanie: ADT množina (set)

Na prednáške 21 sme pracovali s abstraktnou dátovou štruktúrou množina (set).

/* inicializuje prázdnu množinu */
void init(set &s);

/* pridá prvok item do množiny */
void insert(set &s, dataType item); 

/* zistí, či sa v množine nachádza prvok item */
bool find(set &s, dataType item);

/* vypíše všety prvky množiny */
void print(set s);

Ukázali sme si implementácie pomocou

neutriedeného poľa
utriedeného poľa
spájaných zoznamov
binárnych vyhľadávacích stromov

Typ dataType musí podporovať operáciu == a pre utriedené pole a binárny vyhľadávací strom aj operáciu >. Vhodné typy sú teda napr. int, char, príp. double.

Čo ak by sme chceli použiť množinu na ukladanie reťazcov? (napr. mená osôb)
Prepíšeme funkcie tak, aby namiesto operátorov == a > používali funkcie

bool equal(dataType x, dataType y);  // zisti, ci x a y su rovnake 
bool greater(dataType x, dataType y);  // zisti, ci x je viac ako y

Pre daný typ ich potom vhodne naimplementujeme, napr. pre char *

bool equal(dataType x, dataType y) {
    return strcmp(x, y) == 0;
}

bool greater(dataType x, dataType y) {
    return strcmp(x, y) > 0;  //x > y
}

ADT slovník (asociatívne pole)

K prvkom množiny si často chceme uložiť nejakú prídavnú informáciu. Napr. k menu telefónne číslo alebo e-mailovú adresu. Takáto rozšírená štruktúra sa zvykne nazývať slovník alebo asociatívne pole.

V slovníku máme záznamy typu itemType
Súčasťout itemType je kľúč (key), podľa ktorého chceme v slovníku vyhľadávať, napr. meno osoby
Namiesto jedného typu dataType budeme mať itemType (celý záznam) a keyType (iba kľúč)

struct person {
  char * name;
  char * phone;
  char * address;
};
typedef person itemType;
typedef char * keyType;

Základné operácie so slovníkom potom môžu vyzerať napríklad takto:

void insert(dictionary &d, itemType *x);
- do dátovej štruktúry d vloží záznam *x
- predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom
itemType *find(dictionary &d, keyType k);
- nájde záznam s kľúčom k a vráti smerník na neho ho. Ak taký kľúč v slovníku nie je, vráti NULL
itemType * remove(dictionary &d, keyType k);
- vymaže záznam s kľúčom k z d a vráti na záznam smerník

Pre naše typy záznamu a kľúča potrebujeme definovať pomocné funkcie, ktoré budú využívané implementáciou insert, find, remove. Napríklad:

keyType key(itemType *x) {
  return x->name;
}
bool equal(keyType x, keyType y) {
  return strcmp(x, y)==0;
}

Implementácie ADT množina (poľom, zoznamom, binárnym vyhľadávacím stromom) sa dajú ľahko rozšíriť na implementácie ADT slovník.

Jeden príklad uvidíme budúci týždeň

Opakovanie: binárne vyhľadávacie stromy

Binárne vyhľadávacie stromy sú implementáciou ADT množina, alebo ich môžeme rozšíriť o prídavnú informáciu v každom uzle a implementovať slovník. Potrebujeme ale vedieť porovnávať kľúče znamienkom > (alebo funkciou greater).

Binárny vyhladávací strom je binárny strom v ktorom platí:

Hodnota v koreni je väčšia ako všetky hodnoty v ľavom podstrome.
Hodnota v koreni je menšia ako všetky hodnoty v pravom podstrome.
Ľavý aj pravý podstrom sú binárne vyhľadávacie stromy.

Zopakujme si, ako funguje vyhľadávanie v binárnom vyhľadávacom strome:

Porovnáme hľadaný kľúč s kľúčom v koreni
Ak sa rovnajú, našli sme čo hľadáme a končíme
Ak je hľadaná hodnota menšia ako kľúč v koreni, musí byť v ľavom podstrome, ak je väčšia v pravom

node* findNode(node* root, keyType key) {  // nerekurzívna verzia
    node* v = root;
    while (v != NULL && v->key != key) {
        if (key < v->key) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
    return v;
}  

node* findNode(node* root, keyType key) {   // rekurzívna verzia
    if ((root==NULL)||(root->key==key)) return root;    
    
    if (key < root->key) return findNode(root->left);
    else return findNode(root->left);
}

Lexikografické stromy (trie)

Vhodná štruktúra na ukladanie množiny alebo slovníka, v ktorom kľúče sú reťazce. Ide o strom, ktorý ale nie je binárny.

Počet synov v každom vrchole je rovný veľkosti abecedy, každý je označený iným písmenom.
Koreň stromu zodpovedá prázdnemu reťazcu
Vrchol v hĺbke k zodpovedá reťazcu dĺžky k, ktorý dostaneme prečítaním písmen na ceste z koreňa.

Vrchol lexikografického stromu obsahuje:

dáta - písmeno, na ktoré sme sa do vrcholu dostali
pole smerníkov na deti
určenie, či vo vrchole končí nejaké slovo z množiny, prípadne prídavné informácie o tom slove (ak ide o slovník)

Vrchol je teda nasledovného tvaru:

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    bool isWord; // je tento vrchol koncom slova?
    node* next[Abeceda]; // pole smernikov na deti    
};

Alebo môžeme pole smerníkov alokovať vždy, keď vznikne vrchol. Potom definícia nebude závislá od veľkosti abecedy:

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    bool isWord; // je tento vrchol koncom slova?
    node** next; // pole smernikov na deti    
};

Samotný strom je potom iba smerník na koreň

struct trie {  
   /* samotny lexikograficky strom si pamata smernik na koren */
    node* root;
}

Inicializácia a uvoľňovanie stromu

Pri práci s lexikografickým stromom začíname s koreňom, ktorý má v poli nasledovníkov iba smerníky s hodnotou NULL. Koreň je špeciálny vrchol, ktorý neobsahuje žiadne dáta (jeho dáta nastavíme na 0).

void init(trie &t) {
    /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */
    t.root = createNode('\0'); // koren si oznacime specialnym znakom 0
}

Funkcia createNode pracuje nasledovne:

Alokuje pamäť pre nový vrchol.
Alokuje pole smerníkov na deti (ak nemá statickú veľkosť v edefinícii node).
Inicializujeme nasledovníkov na NULL.
Nastavíme hodnoty data a isWord

node* createNode(char data) {
    /* vytvor vrchol stromu s danymi datami */
    node* v = new node;            // novy vrchol 
    v->next = new node*[Abeceda];  // alokuj pole deti
    for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti
    v->isWord = false;
    v->data = data;
    return v;
}

Uvoľňovanie pamäti stromu je pomocou jednoduchej rekurzívnej funkcie destroySubtree(node*), pričom na uvoľnenie celého stromu ju potrebujeme zavolať pre koreň

void destroySubtree(node* v) {
    /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu
     * s korenom vo vrchole v */
    if (v == NULL) return;
    for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]);
    delete[] v->next; // táto časť by nebola potrebná, ak by sme mali next statické
    delete v;
}

void destroy(trie &t) {
    /* uvolni pamat alokovanu pre lexikograficky strom t */
    destroySubtree(t.root);
}

Vkladanie do stromu

Do lexikografického stromu vkladáme reťazec zložený iba z písmen abecedy (pre jednoduchosť pracujeme s abecedou 'A'..'Z' resp. s jej začiatkom veľkosti Abeceda).

Postupujeme v cykle po jednotlivých písmenách vkladaného slova:

Začínam od koreňa stromu
Ak aktuálny vrchol nemá dieťa pre aktuálne písmeno slova, vytvoríme ho.
Potom sa posunieme do dieťaťa pre aktuálne písmeno, už máme zaručené, že existuje.
Keď prídeme na koniec slova, poznačíme si, že daný vrchol zodpovedá slovu

void insert(trie &t, const char* key) {
    /* do lexikografickeho stromu t pridaj slovo key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto
        int c = key[i] - 'A';
        if (v->next[c] == NULL) {  // ak vrchol chyba, spravime novy
            v->next[c] = createNode(key[i]);
        }
        v = v->next[c];
    }

    /* Aktualny vrchol v je koncom slova */
    v->isWord = true;
}

Hľadanie v lexikografickom strome

Vyhľadávanie v strome opäť postupuje po písmenkách vyhľadávaného slova. Kým nedojde na koniec slova snaží sa ísť po hranách, ktoré zodpovedajú písmenkám. V prípade, že na niektorom mieste chýba patričná hrana, znamená to, že takéto slovo sa v strome nenachádza.

bool find(trie& t, const char* key) {
    /* zisti, ci v lexikografickom strome t je kluc key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) {
        int c = key[i] - 'A';
        if (v->next[c] == NULL) return false;
        v = v->next[c];
    }
    return true;
}

Táto funkcia však nefunguje správne.

Ak by sme do stromu vložili iba slovo "AHOJ" a hladali napr. slovo "AH", funkcia nám vráti true, aj keď slovo nie je v množine.
Po prečítaní slova teda ešte potrebujeme skontrolovať, či v aktuálnom vrchole nejaké slovo z množiny naozaj končí

bool find(trie& t, const char* key) {
    /* zisti, ci v lexikografickom strome t je kluc key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) {
        int c = key[i] - 'A';
        if (v->next[c] == NULL) return false;
        v = v->next[c];
    }
    return v->isWord;
}

Vymazávanie z lexikografického stromu

Pri vymazávaní slova potrebujeme:

nájsť vrchol pre dané slovo a nastaviť mu isWord na false (predpokladáme, že slovo v strome bolo)
uvoľniť nepotrebné vrcholy

Najskôr pre jednoduchosť uvoľňovanie vrcholov vynechajme:

void deleteTrie(trie* t, const char* key){
    /* zisti, ci v lexikografickom strome t je kluc key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) {
        int c = key[i] - 'A';
        assert(v->next[c] != NULL);
        v = v->next[c];
    }
    assert(v->isWord);
    v->isWord=false;
}

Vrchol, ktorému sme nastavili isWord na false, môže (ale nemusí) byť nepotrebný

pozná sa to podľa toho, či má nejaké deti
ak nemá deti, môžeme ho zmazať
tým sa môže stať nepotrebný aj jeho rodič a ďalší predkovia

Použijeme rekurziu, kde najskôr vymažeme slovo z určitého podstromu a ak sa tým stal jeho rodič zbytočný, zmažeme aj jeho.

void remove(trie& t, const char* key) {
    /* z lexikografickeho stromu t zmaze slovo key */
    removeFromSubtree(t.root, key, 0);
}

bool removeFromSubtree(node *v, const char *key, int depth) {
    /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth.
     * Vrati true, ak sme zmazali vrchol v, false inak. */
    if (key[depth] == '\0') {  // ak sme na konci slova, odznacime vrchol
        assert(v->isWord);
        v->isWord = false;
    } else {          // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu
        int c = key[depth] - 'A';
        assert(v->next[c] != NULL);
        bool deleted = removeFromSubtree(v->next[c], key, depth + 1);
        if (deleted) {  // ak sme zmazali dieta, poznacime v poli next
            v->next[c] = NULL;
        }
    }
    // zistime, kolko deti ma v
    int numChildren = 0;
    for (int i = 0; i < Abeceda; i++) {
        if (v->next[i] != NULL) numChildren++;
    }
    // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho
    if (numChildren == 0 && !v->isWord && v->data != '\0') {
        delete[] v->next;
        delete v;
        return true;
    }
    return false; 
}

Čo sa stane, ak takto napísanú funkciu spustíme na strome, v ktorom máme iba slovo "AHOJ" a skúsime z neho vymazať slovo "A"?

Vypisovanie stromu

Podobne ako pri binárnych stromoch aj lexikografický strom môžeme vypisovať napríklad mierne modifikovanou funkciou preorder

Aby sa aspoň trochu dalo sledovať, ako to so stromom vyzerá, pridali sme nejaké zátvorky (nie že by veľmi pomohli).

void preorder(node* v){
    if (v==NULL) { return; }
    if(v->data) {  // ak nie sme v koreni
       cout << v->data;
       if(v->isWord) { cout << "*"; }
    }

    cout << "[";
    for (int i=0; i<Abeceda; i++){
        preorder(v->next[i]);
    }
    cout <<"] ";
}

Čo funkcia vypíše pre strom so slovami A, ARE, AS, DO, DOT?

Vypisovanie slov v strome

Oveľa viac by nám pomohlo vypísať všetky slová, ktoré sú v množine.

Funkcia na vypisovanie všetkých slov opäť prejde celý strom rekurzívne

Ak je vo vrchole v koniec nejakého slova, potrebujeme ho vypísať
Aby sme vedeli, ako to slovo vyzerá, pošleme si ho v pomocnom poli ako parameter word
V tomto poli máme vždy uložené znaky na ceste od koreňa k aktuálnemu vrcholu

void printSubtree(int depth, node *v, char* word) {
    /* rekurzívne vypíše všetky slová v podstrome s koreňom v,
     * pričom vrchol v má hĺbku depth 
     * a zodpoveda reťazcu word (nemusí byť ukončený 0)  */
    if (v->isWord) {
        word[depth] = '\0';
        cout << word << endl;
    }
    for (int i = 0; i < Abeceda; i++) {
        if (v->next[i] != NULL) {
            word[depth] = (v->next[i])->data; // pridám si ďalšie písmeno
            printSubtree(depth + 1, v->next[i], word); // zavolám sa rekurzívne
        }
    }
}

Volanie tejto rekurzívnej funkcie je s použitím pomocného poľa, ktorého dĺžku by sme mohli nastaviť ako dĺžku najdlhšieho slova v strome.

void printTrie(trie &t) {
    /* vypise vsetky slova v lexikografickom strome t */
    char *word = new char[maxLen+1];
    printSubtree(0, t.root, word);
    delete[] word;
}

V akom poradí vypíše funkcia slová?

Príklad použitia lexikografického stromu

Na vstupe máme dlhý text a chceme zistiť, koľkokrát sa v ňom nachádzajú jednotlivé slová.

Chceme teda vlastne implementovať štruktúru slovník, v ktorom kľúč je slovo a záznam okrem toho obsahuje počet výskytov tohto slova.
Tentokrát implentujeme špeciálne slovník pre náš účel, nie všeobecnú štruktúru s itemType a keyType
Počet výskytov slova môže nahradiť aj položku isWord, lebo vrchol zodpovedá koncu slova, ak je počet jeho výskytov väčší ako 0.

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    int count;    //počet výskytov slova
    node** next; // pole smernikov na deti    
};

Funkcia increment dostane slovo. Ak toto slovo ešte nie je v strome, tak ho vloží s počtom jedna a ak tam už je, zvýši mu počítadlo.

void increment(trie &t, const char* key) {
    /* v lexikografickom strome t zvys pocitadlo slovu key, ak tam este nie je, pridaj ho */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto
        int c = key[i] - 'A';
        if (v->next[c] == NULL) {  // ak vrchol chyba, spravime novy
            v->next[c] = createNode(key[i]);
        }
        v = v->next[c];
    }

    /* Aktualny vrchol v je koncom slova */
    v->count++;
}

Čo treba zmeniť vo funkcii createNode?
Pri výpise potom vypisujeme nielen slová, ale aj ich počty výskytov.
- Čo ak by sme chceli vypísať iba slovo s najväčším počtom výskytov?
- Čo ak by sme chceli vypísať slová v poradí od najčastejšieho po najmenej časté?

Zdrojové kódy programov

Základná verzia funkcií bez počítania slov
Verzia s počítaním slov

Zhrnutie

Ak máme množinu alebo slovník, v ktorom kľúče sú slová dĺžky D a ich počet je N, aká je zložitosť rôznych implementácií?

Jedno porovnanie dvoch slov na rovnosť alebo podľa abecedy trvá O(D)

Neutriedené pole find O(DN), insert O(1)
Utriedené pole find O(D log N), insert O(DN)
Binárny vyhľadávací strom, priemerný prípad find O(D log N), insert O(D log N)
Lexikografický strom find O(D), insert O(D)

Lexikografické stromy sú obzvlášť vhodné pre implementáciu množiny alebo slovníka s pomerne dlhými textovými kľúčmi. Potrebujú však dosť veľa pamäte (napr. polia next).

Zdrojový kód programu s lexikografickým stromom

#include <iostream>
#include <cassert>
using namespace std;

const int Abeceda = 26;  /* velkost abecedy, znaky cislujeme 0..Abeceda-1 */
const int maxLen = 100;  /* maximalna dlzka slova v strome */

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    bool isWord; // je tento vrchol koncom slova?
    node** next; // pole smernikov na deti    
};

struct trie {  
   /* samotny lexikograficky strom si pamata smernik na koren */
    node* root;
};

node* createNode(char data) {
    /* vytvor vrchol stromu s danymi datami */
    node* v = new node;            // novy vrchol 
    v->next = new node*[Abeceda];  // alokuj pole deti
    for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti
    v->isWord = false;
    v->data = data;
    return v;
}

void init(trie &t) {
    /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */
    t.root = createNode('\0'); // koren si oznacime specialnym znakom 0
}

void destroySubtree(node* v) {
    /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu
     * s korenom vo vrchole v */
    if (v == NULL) return;
    for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]);
    delete[] v->next; 
    delete v;
}

void destroy(trie &t) {
    /* uvolni pamat alokovanu pre lexikograficky strom t */
    destroySubtree(t.root);
}

void insert(trie &t, const char* key) {
    /* do lexikografixkeho stromu t pridaj slovo key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto
        int c = key[i] - 'A';
        if (v->next[c] == NULL) {  // ak vrchol chyba, spravime novy
            v->next[c] = createNode(key[i]);
        }
        v = v->next[c];
    }

    /* Aktualny vrchol v je koncom slova */
    v->isWord = true;
}

bool find(trie& t, const char* key) {
    /* zisti, ci v lexikografickom strome t je kluc key */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) {
        int c = key[i] - 'A';
        if (v->next[c] == NULL) return false;
        v = v->next[c];
    }
    return v->isWord;
}

bool removeFromSubtree(node *v, const char *key, int depth) {
    /* Z podstromu s korenom v zmaz slovo key, pricom aktualna hlbka je depth.
     * Vrati true, ak sme zmazali vrchol v, false inak. */
    if (key[depth] == '\0') {  // ak sme na konci slova, odznacime vrchol
        assert(v->isWord);
        v->isWord = false;
    } else {          // ak nie sme na konci slova, zmazeme ho z prislusneho podstromu
        int c = key[depth] - 'A';
        assert(v->next[c] != NULL);
        bool deleted = removeFromSubtree(v->next[c], key, depth + 1);
        if (deleted) {  // ak sme zmazali dieta, poznacime v poli next
            v->next[c] = NULL;
        }
    }
    // zistime, kolko deti ma v
    int numChildren = 0;
    for (int i = 0; i < Abeceda; i++) {
        if (v->next[i] != NULL) numChildren++;
    }
    // ak v nema deti, nie je oznaceny ako slovo a nie je koren, zmazeme ho
    if (numChildren == 0 && !v->isWord && v->data != '\0') {
        delete[] v->next;
        delete v;
        return true;
    }
    return false; 
}

void remove(trie& t, const char* key) {
    /* z lexikografickeho stromu t zmaze slovo key */
    removeFromSubtree(t.root, key, 0);
}

void printSubtree(int depth, node *v, char* word) {
    /* rekurzívne vypíše všetky slová v podstrome s koreňom v,
     * pričom vrchol v má hĺbku depth 
     * a zodpoveda reťazcu word (nemusí byť ukončený 0)  */
    if (v->isWord) {
        word[depth] = '\0';
        cout << word << endl;
    }
    for (int i = 0; i < Abeceda; i++) {
        if (v->next[i] != NULL) {
            word[depth] = (v->next[i])->data; // pridám si ďalšie písmeno
            printSubtree(depth + 1, v->next[i], word); // zavolám sa rekurzívne
        }
    }
}

void printTrie(trie &t) {
    /* vypise vsetky slova v lexikografickom strome t */
    char *word = new char[maxLen+1];
    printSubtree(0, t.root, word);
    delete[] word;
}


void preorder(node* v){
    if (v==NULL) { return; }
    if(v->data) {  // ak nie sme v koreni
       cout << v->data;
       if(v->isWord) { cout << "*"; }
    }

    cout << "[";
    for (int i=0; i<Abeceda; i++){
        preorder(v->next[i]);
    }
    cout <<"] ";
}

int main(void) {
    trie t;
    init(t);
    insert(t, "ARE");
    insert(t, "AS");
    insert(t, "A");
    insert(t, "DO");
    insert(t, "DOT");
    if (find(t, "ARE")) {
      cout << "Nasiel ARE" << endl;
    }
    if (find(t, "AR")) {
      cout << "Nasiel AR" << endl;
    }
    if (find(t, "AREA")) {
      cout << "Nasiel AREA" << endl;
    }
    preorder(t.root); cout << endl;
    printTrie(t);
    remove(t, "ARE");
    destroy(t);
}

Zdrojový kód programu s počítaním slov

#include <iostream>
#include <cassert>
#include <cstring>
#include <cctype>
using namespace std;

const int Abeceda = 26;  /* velkost abecedy, znaky cislujeme 0..Abeceda-1 */
const int maxLen = 100;  /* maximalna dlzka slova v strome */

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    int count;    //počet výskytov slova
    node** next; // pole smernikov na deti    
};

struct trie {  
   /* samotny lexikograficky strom si pamata smernik na koren */
    node* root;
};

node* createNode(char data) {
    /* vytvor vrchol stromu s danymi datami */
    node* v = new node;            // novy vrchol 
    v->next = new node*[Abeceda];  // alokuj pole deti
    for (int i = 0; i < Abeceda; i++) v->next[i] = NULL; // inicializacia deti
    v->count = 0;
    v->data = data;
    return v;
}

void init(trie &t) {
    /* inicializuj prazdny lexikograficky strom, ktory bude mat iba koren */
    t.root = createNode('\0'); // koren si oznacime specialnym znakom 0
}

void destroySubtree(node* v) {
    /* rekurzivne uvolni pamat pre podstrom lexikografickleho stromu
     * s korenom vo vrchole v */
    if (v == NULL) return;
    for (int i = 0; i < Abeceda; i++) destroySubtree(v->next[i]);
    delete[] v->next; 
    delete v;
}

void destroy(trie &t) {
    /* uvolni pamat alokovanu pre lexikograficky strom t */
    destroySubtree(t.root);
}

void increment(trie &t, const char* key) {
    /* v lexikografickom strome t zvys pocitadlo slovu key, ak tam este nie je, pridaj ho */
    node *v = t.root;
    for (int i = 0; key[i] != 0; i++) { // posuvame sa od korena na spravne miesto
        int c = key[i] - 'A';
        if (v->next[c] == NULL) {  // ak vrchol chyba, spravime novy
            v->next[c] = createNode(key[i]);
        }
        v = v->next[c];
    }

    /* Aktualny vrchol v je koncom slova */
    v->count++;
}

void printSubtree(int depth, node *v, char* word) {
    /* rekurzívne vypíše všetky slová v podstrome s koreňom v,
     * pričom vrchol v má hĺbku depth 
     * a zodpoveda reťazcu word (nemusí byť ukončený 0)  */
    if (v->count > 0) {
        word[depth] = '\0';
        cout << word << " " << v->count << endl;
    }
    for (int i = 0; i < Abeceda; i++) {
        if (v->next[i] != NULL) {
            word[depth] = (v->next[i])->data; // pridám si ďalšie písmeno
            printSubtree(depth + 1, v->next[i], word); // zavolám sa rekurzívne
        }
    }
}

void printTrie(trie &t) {
    /* vypise vsetky slova v lexikografickom strome t */
    char *word = new char[maxLen+1];
    printSubtree(0, t.root, word);
    delete[] word;
}

bool upperLettersOnly(char *word) {
  for(int i=0; word[i]!=0; i++) {
    if(!isupper(word[i])) {
      return false;
    }
  }
  return true;
}

int main(void) {
    trie t;
    init(t);

    char word[maxLen+1];
    cin >> word;
    while(strcmp(word,"*") != 0) {
      if(upperLettersOnly(word)) {
	increment(t, word);
      } else {
	cout << "Skipping " << word << endl;
      }
      cin >> word;
    }

    printTrie(t);
    destroy(t);
}

Prednáška 23

Organizačné poznámky

Dobeh semestra:

DÚ11 (bude zverejnená) a PDÚ4 odovzdávanie do 20.12.
Cvičenia + rozcvičky ešte budúci týždeň - t.j. po Q12
Prednášky:
- dnes opakovanie, príprava na písomku a skúšku
- pondelok 16.12. prednáška nebude
- utorok 17.12. hashovanie, nepreberané črty jazykov C a C++
Na stránke zverejnené ukážkové príklady na písomku a skúšku
Skontrolujte si v známky z DÚ (aktuálne opravene po DU7) aj rozcvičiek, problémy nám hláste čím skôr
- Jednotlivé body za DU a rozcvičky, súčty/percentá podľa pravidiel predmetu sa nezobrazujú

Sylaby predmetu

Základy

Konštrukcie jazyka C

premenné typov int, double, char, bool (vzťah int a char)
podmienky (if, else, switch), cykly (for, while)
funkcie (a parametre funkcií - odovzdávanie hodnotou, referenciou, smerníkom)

void f1(int x){}                                 //hodnotou
void f2(int &x){}                                //referenciou
void f3(int* x){}                                //smerníkom
void f(int a[], int n){}                         //polia bez & (ostanú zmeny)
void kresli(Turtle &t){}                         //korytnačky, SVGdraw a pod. s &

Polia, reťazce (char[])

int A[4]={3, 6, 8, 10}; //spravne
int B[4];               //spravne
B={3, 6, 8, 10};        //nespravne
B[0]=3; B[1]=6; B[2]=8; B[3]=10;

char C[100] = "pes";
char D[100] = {'p', 'e', 's', 0};

funkcie strlen, strcpy, strcmp, strcat

Súbory, spracovanie vstupu

cin, cout alebo printf, scanf
fopen, fclose, feof
fprintf, fscanf
getc, putc, ungetc, fgets, fputs
spracovanie súboru po znakoch, po riadkoch, po číslach alebo slovách

Smerníky, dynamicky alokovaná pamäť, dvojrozmerné polia

int i;    // „klasická“ celočíselná premenná
int *p;   // ukazovateľ na celočíselnú premennú

p = &i;         // spravne
p = &(i + 3);   // zle i+3 nie je premenna
p = &15;        // zle konstanta nema adresu
i = *p;         // spravne ak p bol inicializovany

int * cislo = new int;  // alokovanie jednej premennej
*cislo = 50;
..
delete cislo;

int a[4];
int *b = a;  // a,b su teraz takmer rovnocenne premenne 

int *A = new int[n]; // alokovanie 1D pola danej dlzky
..
delete[] A;

int **a;       // alokovanie 2D pola
a = new int *[n];
for (int i = 0; i < n; i++) a[i] = new int[m];
..
for (int i = 0; i < n; i++) delete[] a[i];
delete[] a;

Dátové štruktúry

Abstraktný dátový typ vektor (rastúce pole)

operácie add, get, set, length

Abstraktný dátový typ množina (set)

operácie (init), insert, find
implementácie pomocou
- neutriedeného poľa
- utriedeného poľa
- spájaných zoznamov
- binárnych vyhľadávacích stromov

Abstraktný dátový typ slovník (asociatívne pole, map)

operácie insert, find, remove
implementácie
- utriedené, neutriedené pole
- spájaný zoznam
- binárny vyhľadávací strom
- lexikografický strom (ak kľúč je reťazec)
- BUDE: hashovacia tabuľka

Abstraktné dátové typy rad a zásobník

operácie pre rad (frontu, queue): init, isEmpty, enqueue, dequeue, peek
operácie pre zásobník (stack): init, isEmpty, push, pop, top
implementácie: v poli alebo v spájanom zozname
využitie: ukladanie dát na spracovanie, odstránenie rekurzie
kontrola zátvoriek a vyhodnocovanie výrazov pomocou zásobníka

Spájané zoznamy

struct node {
    int data;
    item* next;
};
struct linkedList {
    item* first;
};
void insertFirst(linkedList &z, int d){
    /* do zoznamu z vlozi na zaciatok novy prvok s datami d */
    item* p = new item;   // vytvoríme nový prvok
    p->data = d;          // naplníme dáta
    p->next = z.first;    // prvok bude prvým prvkom zoznamu (ukazuje na doterajší začiatok)
    z.first = p;          // tento prvok je novým začiatkom
}

Strom pre výraz (65 – 3*5)/(2 + 3)

Binárne stromy

struct node {
    /* vrchol stromu  */
    dataType data;
    node * left;  /* lavy syn */
    node * right; /* pravy syn */
};

node * createNode(dataType data, node *left, node *right) {
    node *v = new node;
    v->data = data;
    v->left = left;
    v->right = right;
    return v;
}

prehľadávanie inorder, preorder, postorder
použitie na uloženie aritmetických výrazov

Binárne vyhľadávacie stromy

vrcholy vľavo od koreňa menší kľúč, vpravo od koreňa väčší
insert, find, remove v čase závisiacom od hĺbky stromu

Lexikografické stromy

ukladajú množinu reťazcov
nie sú binárne: vrchol môže mať veľa synov
insert, find, remove v čase závisiacom od dĺžky kľúča, ale nie od počtu kľúčov, ktoré už sú v strome

struct node {
    /* vrchol lexikografickeho stromu  */
    char data; // pismeno ulozene v tomto vrchole
    bool isWord; // je tento vrchol koncom slova?
    node* next[Abeceda]; // pole smernikov na deti    
};

Algoritmy

Rekurzia

Rekurzívné funkcie
Vykresľovanie fraktálov
Prehľadávanie s návratom (backtracking)
Vyfarbovanie
Prehľadávanie stromov

Triedenia

nerekurzívne: Bubblesort, Selectionsort, Insertsort
rekurzívne: Mergesort, Quicksort
súvisiace algoritmy: binárne vyhľadávanie, hľadanie mediána

Matematické úlohy

Euklidov algoritmus, Eratostenovo sito
Práca s polynómami (vyhodnocovanie, sčítanie)
Práca s aritmetickými výrazmi: rekurzívne vyhodnocovanie, vyhodnocovanie postfixovej formy, prevod z infixovej do postfixovej, reprezentácia vo forme stromu

Cvičenia 12

Máme binárny strom, v ktorom má každý vrchol buď dve deti a v dátovom poli uložený znak '#' alebo nemá žiadne deti a v dátovom poli má uložený znak '*'. Keď tento strom vypíšeme v preorder poradí, dostaneme postupnosť ##*#*** Nakreslite, ako vyzerá tento strom.

Nakreslite binárny vyhľadávací strom, ktorý dostaneme, ak do prázdneho slovníka postupne vkladáme záznamy s kľúčami 3, 4, 1, 2, 5, 6 (v tomto poradí).

Nakreslite lexikografický strom s abecedou {a,b}, do ktorého sme vložili reťazce aba, aaab, baa, bab, ba. Vrcholy, ktoré zodpovedajú koncu niektorého slova, zvýraznite dvojitým krúžkom.

Napíšte funkciu dvojicky(node *root), ktorá spočíta počet všetkých vnútorných vrcholov v binárnom strome s koreňom root takých, že ich ľavé aj pravé dieťa majú v svojom dátovom poli uloženú tú istú hodnotu.

Napíšte rekurzívnu funkciu, ktorá každému uzlu binárneho stromu prirobí smerník na otca do položky parent typu node *. Funkcia bude mať hlavičku void assignParent(node *v, node *parent) kde vrchol parent je otcom vrchola v, alebo NULL ak v je koreň a teda nemá otca. Funkcia doplní otca vrcholu v aj všetkým jeho potomkom, t.j. napr. synom vrchola v nastaví ako otca smerník na v. Použite nasledujúcu štruktúru pre vrchol stromu:

struct node {
    /* vrchol stromu  */
    dataType data;
    node * left;  /* lavy podstrom */
    node * right; /* pravy podstrom */
    node * parent; /* otec vrcholu */
};

Napíšte funkciu, ktorá dostane utriedené pole čísel a vytvorí z nich binárny vyhľadávací strom (priamo, bez použitia funkcie insert). Pokúste sa strom vytvoriť tak, aby ľavý a pravý podstrom každého vrcholu obsahovali približne rovnako veľa prvkov.
- Doporučujeme postupovať rekurzívne, pričom napíšte funkciu s hlavičkou napr. node * vytvorStrom(int a[], int l, int r), ktorá vytvorí strom pre časť poľa a od pozície l po pozíciu r.

Prednáška 24

Hešovacie tabuľky

Predpokladajme, že chceme implementovať jednoduchú množinu (set) celých čísel.

Hlavné operácie insert, find, prípadne delete
Zatiaľ sme videli: utriedené pole, neutriedené pole, spájaný zoznam, binárny vyhľadávací strom (keďže nejde o reťazce, lexikografické stromy sa príliš nehodia)

Priame adresovanie

Videli sme však ešte jeden prístup: ak sú prvky množiny čísla z {0,1,...,m-1}, môžeme množinu reprezentovať ako pole boolovských hodnôt dĺžky m (viď pole bolo používané pri generovaní variácií bez opakovania)
Tento prístup sa volá priame adresovanie (direct adressing)
insert, delete aj find v čase O(1)

struct set {
   int m;
   bool *a;
}

void init(set &s, int max) {
  s.m = max;
  s.a = new bool[max];
  for(int i=0; i<max; i++) {
     a[i]=false;
  }
}

void insert(set &s, int k) {
  assert(0<=k && k<s.m);
  s.a[k] = true;
}

bool find(set &s, int k) {
  assert(0<=k && k<s.m);
  return s.a[k];
}

Jednoduché hešovanie

Priame adresovanie sa príliš nehodí, ak prvky môžu byť veľmi veľké, lebo potrebuje veľa pamäte. Hešovanie je jednoduchá finta, ktorá funguje nasledovne:

vytvoríme si hešovaciu tabuľku: pole veľkosti m rovnakého typu ako prvky množiny, napr. int
nech K je množina všetkých možných prvkov množiny (kľúčov)
Naprogramujeme hešovaciu funkciu, ktorá transformuje prvky množiny K na indexy poľa, teda pôjde o funkciu h : K -> {0 , 1 , . . . , m−1}.
Hešovacia funkcia by mala byť jednoduchá a rýchla, ale pritom by nemala prideľovať často rovnaké indexy (mala by kľúče do tabuľky distribuovať rovnomerne).
Často sa používa funkcia h(k) = k mod m (je dobré, ak v tomto prípade m je prvočíslo a nie je blízko mocniny 2).
- pozor, -10 % 3 je -1, takže radšej použijeme absolútnu hodnotu z k (funkcia abs z knižnice cstdlib)

struct set {
   int m;
   int *data;  // data je pole dlzky m
}

int hash(int k, int m){
    return abs(k) % m;
}

Vkladanie

spočítame miesto hash(k) a prvok tam vložíme

void insert(set &s, int k) {
    int index = hash(k, s.m);
    s.data[index]=k;
}

Vyhľadávanie

ak prvok s kľúčom k je v tabuľke, musí byť na mieste hash(k).
skontrolujeme toto miesto a ak tam je niečo iné ako k, k sa v tabuľke nenachádza

bool find(set &s, int k){
    int index = hash(k, s.m);
    return s.data[index]==k;
}

Problémy:

na akú hodnotu inicializovať pole s.data?
čo ak chceme vložiť prvok na miesto, kde už je niečo uložené?

Kolízie

Pri vkladaní prvku sme narazili na problém, ak na už obsadané miesto chceme vložiť iný prvok. Môže sa stať, že dva prvky x a y sa zahešujú na rovnakú pozíciu h(x) = h(y). Takémuto javu hovoríme kolízia. Existuje viacero spôsobov, ako ju riešiť.

Budeme aj tak vkladať na toto miesto, len tam nebude iba jeden prvok, ale potenciálne viac prvkov v spájanom zozname
Budeme hľadať inú voľnú pozíciu v tabuľke
- buď postupným prezeraním nasledovných prvkov
- alebo s pozeraním prvkov s nejakým daným krokom
- o tomto sa dozviete viac o rok na predmete ADŠ

Riešenie kolízií pomocou spájaných zoznamov

Namiesto prvkov typu int budeme mať v každom políčku hashovacej tabuľky spájaný zoznam s prvkami, ktoré hešovacia funkcia priradila na toto políčko.

struct node {
    int item;
    node* next;
};

struct set {
    node** data;
    int m;
};

Vyhľadávanie pracuje na spájanom zozname, ktorý sa nachádza na správnom mieste hešovacej tabuľky.

Správny index dostaneme pomocou hash(k,s.m), kde k je hľadaný kľúč a s.m je veľkosť tabuľky s.

bool find(set &s, int k){
    int index = hash(k, s.m);
    node* v = s.data[index];
    while(v!=NULL){
        if(v->item==k) return true;
        v = v->next;
    }
    return false;
}

Pri vkladaní stačí nový prvok pridať na začiatok spájaného zoznamu na správnom mieste tabuľky.

Prečo vkladáme na začiatok a nie na koniec?
Ak by sme chceli kontrolovať, či tam vkladaný prvok už náhodou nie je, museli by sme najskôr prejsť a skontrolovať celý spájaný zoznam

void insert(set &s, int k) {
    int index = hash(k, s.m);
    node* temp = new node;
    temp->item = k;
    temp->next = s.data[index];
    s.data[index] = temp;
}

Ďalšie funkcie

Vymazávanie prebieha podobne ako všetky ostatné operácie na spájanom zozname, ktorý je na mieste tabuľky, kam nás nasmeroval zahešovaný kľúč.
Inicializácia vytvorí tabuľku data a nastaví všetky smerníky v nej na NULL.

Príklad. Ako bude vyzerať hešovacia tabuľka pri riešení kolízií pomocou spájaných zoznamov, ak hešovacia funkcia je |k| mod 5 a vkladáme prvky 13, -2, 0, 8, 10, 17?

Zložitosť

Rýchlosť závisí od toho, akú máme veľkosť tabuľky m, hešovaciu funkciu a koľko prvkov sa zahešuje do jedného políčka.
V najhoršom prípade sa všetky prvky zahešujú do toho istého políčka, teda máme insert O(1) a find O(n), kde n je počet prvkov množiny.
Ak máme štastie a v každom políčku máme len niekoľko málo (konštantný počet) prvkov, budeme mať insert aj find O(1).
- Ak je tabuľka dosť veľká a hešovacia funkcia vhodne zvolená, tento príklad je pomerne obvyklý.
- Hešovacie tabuľky sa často používajú v praxi.
Viac budúci rok na ADŠ.

Implementácia ADT slovník pomocou hešovania

Pripomíname: abstraktný dátový typ (ADT)

Určíme, aké operácie by mala dátová štruktúra spĺňať (hlavičky funkcií), nestaráme sa o implementáciu
Napríklad ADT slovník poskytuje operácie init, insert, find, delete, atď
Videli sme aj ďalšie ADT, napr. vektor, zásobník, rad, množina
Pre jeden ADT môže byť viacero implementácií, napr. slovník pomocou triedeného poľa, netriedeného poľa, binárneho vyhľadávacie stromu, hešovacou tabuľkou atď
Program, ktorý slovník používa, netreba meniť kvôli zmene implementácie (alebo len veľmi málo, napr. pridanie hešovacej funkcie)
Budúci semester si ukážeme ako ADT krajšie implementovať pomocou objektovo-orientovaného programovania a generického programovania
- Je to však len zmena syntaxe (hlavičky funkcií, definície typov a pod.), algoritmy a dátové štruktúry (zoznamy, polia) zostávajú tie isté

Ukážeme si program, ktorý

implementuje ADT slovník pomocou hešovacej tabuľky
použije tento slovník na spočítanie frekvencie výskytu slov vo vstupnom texte
- toto sme robili aj na prednáške o lexikografických stromoch, tam sme si však spravili štruktúru špecificky na tento účel, tu použijeme všeobecný slovník

Štruktúra programu

definícia typov (keyType, itemType) špecifických pre dané použitie, pomocné funkcie pre tieto typy (napr. key, equal, hash)
implementácie slovníkových funkcií (insert, find, delete,...)
použitie slovníka na daný účel

Druhú časť môžeme hocikedy vymeniť za inú implementáciu slovníka bez zmeny zvyšku programu. Alebo zmenou prvej a tretej časti môžeme využiť ten istý slovník na iný účel.

Definícia typov a pomocných funkcií

V danej aplikácii si musíme najskôr zadefinovať typy itemType a keyType, ktoré určujú, aké záznamy a aké kľúče budeme do slovníka ukladať.

struct word {
  char * str;
  int count;
};
typedef word itemType;
typedef char * keyType;

Ďalej potrebujeme funkciu, ktorá nám pre záznam dá kľúč a funkciu, ktorá zistí, či sú dva kľúče rovnaké. Niektoré implementácie slovníka budú potrebovať aj ďalšie podobné funkcie, napr. zistiť, či je jeden kľúč menší ako druhý.

keyType key(itemType *x) {
  return x->str;
}
bool equal(keyType x, keyType y) {
  return strcmp(x, y)==0;
} 
int hash(keyType x, int m) {
    // Funkcia dostane vstupny retazec str a velkost hashovacej tabulky m.
    // Vrati cislo medzi 0 a m-1
    int h = 0;
    char *c = str;
    while (*c) {
        h = (h*256 + (*c))%m;
        c++;
    }
    h = abs(h) % m;
    return h;
}

Slovníkové funkcie

A tu sú hlavičky základných slovníkových funkcií:

void insert(dictionary &d, itemType *x);
- do dátovej štruktúry d vloží záznam *x
- predpokladá, že v štruktúre je dosť miesta a nie je tam záznam s rovnakým kľúčom
itemType *find(dictionary &d, keyType k);
- nájde záznam s kľúčom k a vráti smerník na neho ho. Ak taký kľúč v slovníku nie je, vráti NULL
itemType* remove(dictionary &d, keyType k);
- vymaže záznam s kľúčom k z d a vráti na záznam smerník

A pomocné funkcie:

void init(dictionary &d, int maxN);
- vytvorí slovník, do ktorého sa zmestí maxN záznamov (niektoré implementácie maxN nepotrebujú, rastú podľa potreby)
void destroy(dictionary &d);
- uvoľní pamäť, ktorú zaberá slovník (neuvoľnuje pamäť záznamov)
itemType ** items(dictionary &d, int &n);
- vráti novo alokované pole so smerníkmi na jednotlivé záznamy, ich počet dá do n

Implementácie vyzerajú podobne ako pre implementáciu množiny, napr. funkcia find:

itemType* find(dictionary &d, keyType k) {
    // nájde záznam s kľúčom k a vráti smerník na neho ho. 
    // Ak taký kľúč v slovníku nie je, vráti NULL 
    int index = hash(k, d.m); // najdi poziciu v tabulke
    node* v = d.data[index]; // prehladaj spajany zoznam
    while (v != NULL) {
        if (equal(key(v->item), k)) { // spravny prvok najdeny
            return v->item;
        }
        v = v->next;
    }
    return NULL; // kluc nebol najdeny v slovniku
}

Využitie na počítanie slov

Samotný program používajúci slovník na počítanie slov môže vyzerať nejako takto:

int main() {
    dictionary d; // vytvorenie slovnika
    init(d, 19);

    char word[maxLen + 1];
    cin >> word;
    while (strcmp(word, "*") != 0) { // nacitavanie slov zo vstupu
        itemType *item = find(d, word); // najdeme zaznam pre slovo
        if (item != NULL) { // ak existuje, zvysime mu pocitadlo
            item->count++;
        } else { // ak zaznam neexistuje, vytvorime novy
            item = new itemType;
            item->str = new char[strlen(word) + 1]; // pamat pre slovo
            strcpy(item->str, word);
            item->count = 1;
            insert(d, item); // a vlozime ho do slovnika
        }
        cin >> word;
    }

    int n; // pocet zaznamov v slovniku
    itemType **a = items(d, n); // vsetly zaznamy v slovniku

    for (int i = 0; i < n; i++) { // vypis vsetky zaznamy
        cout << a[i]->str << " " << a[i]->count << endl;
    }

    for (int i = 0; i < n; i++) { // odalokuj vsetky zaznamy
        delete[] a[i]->str;
        delete a[i];
    }
    delete[] a; // odalokuj aj pole a

    destroy(d); // odalokuj samotny slovnik
}

Zdrojový k programu na ADT slovník pomocou hešovania

#include <cstring>
#include <iostream>
#include <cstdlib>
#include <cassert>
using namespace std;

const int maxLen = 100; // maximalna dlzka slova na vstupe 

struct word { // struktura pre jdno slovo 
    char * str; // samotne slovo ako retazec 
    int count; // pocet vyskytov slova
};
typedef word itemType; // typ celeho zaznamu pre slovnik
typedef char * keyType; // typ kluca pre slovnik

keyType key(itemType *x) { // pre dany zaznam v slovniku vrat kluc
    return x->str;
}

bool equal(keyType x, keyType y) { // su dva kluce totozne?
    return strcmp(x, y) == 0;
}

int hash(keyType x, int m) {
    // Funkcia dostane vstupny kluc x (retazec) a velkost hashovacej tabulky m.
    // Vrati cislo medzi 0 a m-1
    int h = 0;
    char *c = x;
    while (*c) {
        h = (h * 256 + (*c)) % m;
        c++;
    }
    h = abs(h) % m;
    return h;
}

struct node { // vrchol spajaneho zoznamu v slovniku
    itemType* item; // samotne data vo vrchole
    node* next; // dalsi vrchol v zozname
};

struct dictionary { // struktura pre slovnik pomocou hesovacej tabulky
    node** data; // pole dlzky m smernikov na spajane zoznamy
    int m; // dlzka pola data
    int size; // pocet prvkov v slovniku
};

void init(dictionary &d, int m) {
    // vytvori slovnik s hesovacou tabulkou velkosti m
    d.m = m;
    d.data = new node*[m]; // alokovanie tabulky
    for (int i = 0; i < m; i++) {
        d.data[i] = NULL; // vsetky zoznamy su prazdne
    }
    d.size = 0; // v slovniku je 0 zaznamov
}

void destroy(dictionary &d) {
    // uvolni pamt, ktory zabera hesovacia tabulka a spajane zoznamy
    // neuvolnuje pamat jednotlivych zaznamov
    for (int i = 0; i < d.m; i++) {
        node* it = d.data[i]; // uvolni pamat zoznamu na pozicii i
        while (it) {
            node* next = it->next;
            delete it;
            it = next;
        }
    }
    delete[] d.data; // uvolni tabulku
}

void insert(dictionary &d, itemType *x) {
    // do slovnika d vlozi prvok x
    // predpoklada, ze slovnik s takym klucom este v slovniku nie je
    int index = hash(key(x), d.m); // najdi poziciu v tabulke
    node* temp = new node; // vloz novy vrchol na zaciatok zoznamu
    temp->item = x;
    temp->next = d.data[index];
    d.data[index] = temp;
    d.size++; // zvys pocet prvkov v slovniku
}

itemType* find(dictionary &d, keyType k) {
    // nájde záznam s kľúčom k a vráti smerník na neho ho. 
    // Ak taký kľúč v slovníku nie je, vráti NULL 
    int index = hash(k, d.m); // najdi poziciu v tabulke
    node* v = d.data[index]; // prehladaj spajany zoznam
    while (v != NULL) {
        if (equal(key(v->item), k)) { // spravny prvok najdeny
            return v->item;
        }
        v = v->next;
    }
    return NULL; // kluc nebol najdeny v slovniku
}

itemType* remove(dictionary &d, keyType k) {
    // vymaže záznam s kľúčom k z d (ak tam je)
    // navratova hopdnota je zaznam vymazany zo slovnika
    // (jeho pamat nebola uvolnena)
    int index = hash(k, d.m); // najdi poziciu v tabulke
    node** p = &(d.data[index]); // vymaz zo zoznamu pomocou dvojiteho smernika
    while (*p != NULL) {
        node* v = *p; // aktualny vrchol zoznamu
        if (equal(key(v->item), k)) { // nalsi sme hladany kluc - mazeme
            *p = v->next; // *p je smernik, ktory ukazoval na v
            itemType *item = v->item; // odlozime si zaznam, aby sme ho mohli vratit
            delete v; // uvolnime pamt pre uzol zoznamu
            d.size--; // znizime pocet zaznamov v slovniku
            return item; // vratime item, skoncime s hladanim 
        }
        p = &(v->next);
    }
    return NULL; // zaznam sme nenasli, nic sme nezmazali
}

itemType ** items(dictionary &d, int &n) {
    // vráti novo alokované pole so smerníkmi na záznamy, ich počet dá do n 
    n = d.size;
    itemType ** a = new itemType *[n]; // alokujeme pole
    int num = 0; // pocet zaplnenych prvkov v a
    for (int i = 0; i < d.m; i++) { // prejdeme cez hesovaciu tabulku
        node* v = d.data[i];
        while (v != NULL) { // prejdeme cez kazdy spajany zoznam
            a[num] = v->item; // vsetko pridavame do pola a
            num++;
            v = v->next;
        }
    }
    assert(num == n);
    return a;
}

int main() {
    dictionary d; // vytvorenie slovnika
    init(d, 19);

    char word[maxLen + 1];
    cin >> word;
    while (strcmp(word, "*") != 0) { // nacitavanie slov zo vstupu
        itemType *item = find(d, word); // najdeme zaznam pre slovo
        if (item != NULL) { // ak existuje, zvysime mu pocitadlo
            item->count++;
        } else { // ak zaznam neexistuje, vytvorime novy
            item = new itemType;
            item->str = new char[strlen(word) + 1]; // pamat pre slovo
            strcpy(item->str, word);
            item->count = 1;
            insert(d, item); // a vlozime ho do slovnika
        }
        cin >> word;
    }

    int n; // pocet zaznamov v slovniku
    itemType **a = items(d, n); // vsetly zaznamy v slovniku

    for (int i = 0; i < n; i++) { // vypis vsetky zaznamy
        cout << a[i]->str << " " << a[i]->count << endl;
    }

    for (int i = 0; i < n; i++) { // odalokuj vsetky zaznamy
        delete[] a[i]->str;
        delete a[i];
    }
    delete[] a; // odalokuj aj pole a

    destroy(d); // odalokuj samotny slovnik
}

Pokyny a rady ku skúške

Viď informácie k testu a skúške.

Nepreberané črty jazykov C a C++

Na zvyšku prednášky si stručne ukážeme niektoré črty jazykov C a C++, ktoré sme počas semestra nepreberali. Nebudeme preberať väčšie detaily; cieľom je, aby ste neboli príliš prekvapení pri štúdiu existujúcich programov, resp. poskytnúť inšpiráciu pre ďalšie samoštúdium.

Tento materiál nebude vyžadovaný na skúške a ani Vám neodporúčame tieto črty jazyka používať, ak ste sa s nimi dostatočne pred skúškou neoboznámili. Dnes vynecháme objektovo-orientované programovanie v jazyku C++. Objektovo-orientovanému programovaniu (v jazyku Java) sa budeme venovať budúci semester.

Jazyk C

Jazyk C existuje v rôznych verziách.
V starších verziách nefungujú mnohé veci z jazyka C++, ktoré sme bežne používali, napr. komentáre vo forme //, všetky deklarácie premenných musia byť na začiatku funkcie a pod.

Ďalšie typy premenných

Celé čísla: short int, long int, unsigned int, ...
- Veľkosť jednotlivých typov závisí od kompilátora platformy
Desatinné čísla: float (menej presný ako double)
V staršom C-čku nie je bool, používa sa int, ktorý má hodnotu 0 pre false a nenulovú (napr. 1) pre true.
Zložený typ union: v tom istom mieste v pamäti môže byť jedna z alternatívnych premenných, napr. pri aritmetickom strome by sme mohli uložiť buď smerníky na deti, alebo hodnotu v liste a ušetriť tak trochu pamäti
Typ enum: vymenujeme možné hodnoty, tie sa stanú celočíselnými konštantami: enum farby {biela, cierna, cervena};

Operátory

Okrem operátorov, ktoré sme bežne používali, existuje niekoľko ďalších, napríklad:

Bitové operátory pracujú s celým číslom ako s poľom bitov (vhodnejšie sú unsigned typy):
- << a >> posúvajú bity doľava a doprava, zodpovedajú násobeniu a deleniu mocninami dvojky
- & (and po bitoch), | (or po bitoch), ^ (xor po bitoch), ~ (negácia po bitoch)
Ternárny operátor ?: má tvar (podmienka)?(hodnota pre true):(hodnota pre false), napr.

 cout << x << " je " << ((x%2==0) ? "parne" : "neparne") << endl;

Pozor na rozdiel medzi a[i++]=0 a a[++i]=0, prehľadnejšie použiť dva príkazy: a[i]=0; i++ alebo i++; a[i] = 0;

Príkaz do-while

Nasledujúce dva spôsoby písania cyklu sú viac-menej ekvivalentné:

do { 
  prikazy;
} while(podmienka)

while(true) {
  prikazy;
  if(!podmienka) break;
}

Makrá a konštanty

V C-čku nie sú klasické konštanty, robia sa pomocou makier. Nasledujúce dva riadky majú podobný význam:

#define MAXN 100
const int MAXN=100;

Okrem konštánt môžeme definovať aj zložitejšie makrá s parametrami:

/* definicia makra: */
#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))

/* priklad pouzitia: */
cout << MIN(a*a, b+5);
/* preprocesor dosadi, dostane: */
cout << ((a*a) < (b+5) ? (a*a) : (b+5));

Treba dať kopu zátvoriek, aby nedošlo k interakcii s okolím použitia príkazu max

Delenie programu na súbory

Väčší program chceme rozdeliť na viac súborov
Chceme vytvárať a používať vlastné knižnice - skupiny funkcií s podobným účelom
- Napríklad knižnica implementujúca funkcie pracujúce so zásobníkom
Knižnicu rozdelíme na dva súbory, napr. stack.h a stack.c resp. stack.cpp
V hlavičkovom súbore (header file) zadeklarujeme funkcie, ale neuvádzame ich kód, napr.:

typedef int dataType;
struct stack {
    int top;  /* pozicia vrchného prvku zásobníka */
    dataType *items; /* pole prvkov */
};
void init(stack &s);
bool isEmpty(stack &s);
void push(stack &s, dataType data); 
dataType pop(stack &q);

Programy, ktoré chcú použiť stack, použijú include na tento súbor

#include "stack.h"

V súbore stack.cpp uvedieme kód funkcií, napr.

#include "stack.h"
const int maxN = 100;
void init(stack &s) {
    s.top = -1;
    s.items = new dataType[maxN];
}
...

Všimnite si, že v include dávame meno štandardných knižníc v <>, našich vlastných v ""
Pri štandardných knižniciach sa v C-čku používa prípona h, v C++ sa namiesto toho väčšinou pridá c na začiatok (že je to knižnica z čistého C)
- Napr. <cmath> vs. <math.h>
Ako zabrániť, aby sa vložilo include viackrát?
- #ifndef IDENTIFIKATOR #define IDENTIFIKATOR ... #endif
- Preprocesor umožňuje okrem toho aj ďalšie podmienené príkazy #if VYRAZ ... #else ... #endif alebo #ifdef IDENTIFIKATOR ... #else ... #endif

C nemá posielanie parametrov referenciou

... používame teda smerníky

void swap(int &a, int &b) {
  int tmp = a;
  a = b;
  b = tmp;
}

void swap(int *a, int *b) {
  int tmp;
  tmp = *a;
  *a = *b;
  *b = tmp;
}

Zopár užitočných funkcií

Alokácia pamäte

V C-čku sa nepoužíva new a delete, resp. new[] a delete[]
Pamäť sa alokuje funkciou malloc, ktorá alokuje kus pamäte s daným počtom bajtov
- Ak sa nepodarilo, vráti NULL
- Inak vrati pointer na void, treba pretypovať
- Veľkosť spočítame operátorom sizeof

#include <stdlib.h>

/* vytvorime pole 100 int-ov */
int *a = (int *)malloc(sizeof(int) * 100);
/* odalokujeme pole a */
free(a);

Triedenie

Funkcia qsort z knižnice stdlib.h
Dostane pole, počet jeho prvkov, veľkosť každého prvku a funkciu, ktorá porovná dva prvky
- Funkciu teda posielame ako parameter
- Táto porovnávacia funkcia dostane smerníky na dva prvky v type void *
- Vráti záporné číslo, ak prvý prvok je menší, nulu, ak sú rovnaké a kladné číslo, ak prvý je väčší
Ak si napíšeme porovnávaciu funkciu, môžeme triediť prvky hocijakého typu

int compare (const void * a, const void * b) {
  return (*(int*)a - *(int*)b);
}
int a[] = {5, 3, 2, 4, 1};
qsort (a, 5, sizeof(int), compare);

Podobne je aj funkcia bsearch na binárne vyhľadávanie v striedenom poli

Jazyk C++

Generické funkcie

Často chceme napísať algoritmus, ktorý by mohol fungovať veľa rôznych typoch
Napr. triediť môžeme celé alebo desatinné čísla, reťazce, zložitejšie štruktúry s určitým kľúčom a pod.
Funkcia qsort nám to umožňuje, ale musíme sa zapodievať veľkosťami a pretypovaním, kde sa dajú ľahko narobiť chyby.
V C++ sa dajú písať funkcie, ktoré majú typ ako parameter:

template <class T>
T max (T a, T b) {
  return (a>b)? a : b;
}

int i=3;
int j=5;
int k=max<int>(i,j);

Preťaženie operátorov

Pre naše typy si vieme zadefinovať nové operátory
Napr. dve mená porovnávame najskôr podľa priezviska, pri zhode podľa krstného mena

struct meno {
    char *krstne, *priezvisko;
};

bool operator < (meno x, meno y) {
    return strcmp(x.priezvisko, y.priezvisko)<0
            || strcmp(x.priezvisko, y.priezvisko)==0
            && strcmp(x.krstne, y.krstne)<0;
}

Podobne môžeme zadefinovať napr. operátor + a * pre náš struct reprezentujúci trebárs polynómy alebo komplexné čísla...
cin << "Hello" používa preťažený operátor << ak na ľavej strane je stream a na pravej reťazec

Stringy

Okrem klasických C-čkových reťazcov môžeme použiť aj C++ typ string.
Majú elegantnejšie používanie, sami si určujú potrebnú veľkosť pamäte
Sú to objekty, do funkcií odovzdávame cez &
Jednotlivým znakom pristupujeme pomocou [] (ako u polí) alebo pomocou metódy at

#include <string>
using namespace std;

int main(void) {

    char cstr[100] = "Ahoj\n";
    string str = "Ako sa mas?\n";
    string str2;

    /* mozeme priradovat konstantne retazce, C-ckove retazce (polia znamkov)
      aj C++ stringy. */
    str2 = "Ahoj\n";
    str2 = cstr;
    str2 = str;
    /* meranie dlzky */
    cout << "Dlzka je: " << str.length() << endl;

    /* Funguje porovnanie pomocou ==, !=, <,...
     * (bud dvoch C++ stringov, alebo C++ stringu a C stringu)
     * Znamienko + znamená zreťazenie. */
    str2 = cstr + str;
    str2.push_back('X');
    str2.push_back('\n');
    cout << str2;

    if (str < str2) {
        cout << "Prvy je skor" << endl;
    } else if (str == str2) {
        cout << "Rovnaju sa" << endl;
    } else {
        cout << "Druhy je skor" << endl;
    }
}

Pomocou funkcie c_str() vieme získať zo stringu premennú typu const char*

Streamy

Každý textový súbor môžeme chápať ako postupnosť znakov (podobne ako vstup/výstup z konzoly). Teda aj textový súbor je vlastne stream, ktorý môžeme postupne (zľava doprava) čítať alebo do neho zapisovať.
Textové súbory teda môžeme načítávať alebo zapisovať pomocou analógie k cin a cout
Budeme využívať typy a funkcie zadefinované v knižnici fstream.

#include <fstream>

using namespace std;

int main (void) {
  ofstream o;
  o.open ("Test.txt");     // otvorenie súboru
  o << 'z';                // zapíše 1 znak
  o << "Toto je retazec";  // zapíše reťazec znakov (= postupnosť znakov)
  o << endl;               // 1 znak = nový riadok – znak \ má špeciálny význam
  o << "Text";             // v súbore bude toto na začiatku nového riadka
  o << endl;
  o << 10*32 ;             // môžeme zapísať hodnotu výrazu ako reťazec znakov
  o << endl;
  o << "10*32=" << 10*32 << endl;          // zapíše sa zľava doprava
  o << "1 rovna sa 4? " << (1==4) << endl; // pozor na priority operátorov ... 1==4 musí byť v zátvorkách !!!
  o.close ();              // zatvorenie súboru
}

ofstream tiež umožňuje formátovanie výstupu napríklad pomocou modifikátorov fixed,setprecision(),setfill(),setw()

Podobne môžeme otvoriť aj súbor, z ktorého budeme čítať vstup. V príklade načítame pole celých čísel.

#include <fstream>
#include <iostream>

using namespace std;
const int MAX=100;

int main (void) {
  ifstream f;
  int pocet, A[MAX];
  
  f.open ("VSTUP.txt");
  if (f.fail ()) return 1;  // return = návrat z funkcie – koniec programu
  f >> pocet;
  for (int i=0; i<pocet; i++) {
    f >> A[i];
  }

  for (int i=0; i<pocet; i++) {
    cout<< A[i] << " ";
  }
  f.close();
}

Pri načítaní sme sa už stretli s funkciou f.fail(), ktorá vrátila logickú hodnotu pravda ak vznikla chyba (väčšinou pri otovrení neexistujúceho súboru). Druhou možnosťou je testovať správne otvorenie pomocou testovania premennej typu ofstream alebo ifstream. Je to ekvivalentné (snáď skoro vždy) funkcii fail.

  ifstream fin("VSTUP.txt"); // input
  if(!fin) {
    cout << "Cannot open VSTUP.txt file.\n";
    return 1;
  }

  ofstream fout("VYSTUP.txt"); // output, normal file
  if(!fout) {
    cout << "Cannot open VYSTUP.txt file.\n";
    return 1;
  }

Testovanie konca súboru môžeme robiť pomocou funkcie eof

ifstream fin("VSTUP.txt"); // input
char c;

while(!fin.eof()) {
  fin>>c;
  cout<<c;
}

Pre streamy je praktická funkcia getline, ktorá načíta zo streamu celý riadok. Nasledovný príklad spočíta v jednotlivých riadkoch počet bodiek.

int main(void){
ifstream f("VSTUP.txt");;
string line;
int poc;

while (getline(f,line)){
 poc=0;
 for (int i=0; i<line.length(); i++){
   if (line[i]=='.') poc++;
 }
 cout << poc <<endl;
}

Niektoré užitočné štruktúry z knižnice STL

STL (standard template library)

Veľká knižnica rôznych dátových štruktúr
Manuál napr. http://www.sgi.com/tech/stl/ alebo http://www.cplusplus.com/reference/stl/
Generické štruktúry, ktoré môžu uchovávať dáta rôznych typov
- elegantnejšie ako naše riešenie s dataType
- v jednom programe môžeme mať štruktúry uchovávajúce rôzne typy
Budúci semester sa naučíme pracovať s obdobnými štruktúrami v Jave

Štruktúra vector

Pole s dynamickou alokáciou pamäte, čo znamená, že ak nestačí pôvodne alokovaný priestor, alokuje si sám väčší.
Podobne ako keď sme si to programovali sami počas semestra
Deklarovať vector môžeme jedným z nasledujúcich spôsobov

vector<int> A;       //vytvorí pole celých čísel
vector<int> A(10);   //vytvorí pole 10 celých čísel, ktoré všetky nastaví na default hodnotu
vector<int> A(5,1);  //vytvorí pole 5 celých čísel, ktoré nastaví na 1

Prístup k prvkom vectora je možný dvoma spôsobmi
- klasicky pomocou A[index] - má podobné problémy ako polia
- A.at(index) je bezpečnejší spôsob, kedy v prípade indexu mimo rozsahu nebude robiť neplechu

Vkladanie do poľa je možné tiež dvomi spôsobmi - ale pozor na miešanie
- do už vytvoreného miesta (ak sme tak deklarovali vector) pomocou priradenia (ďalší priestor získam pomocou A.resize(nova hodnota))
- pomocou A.push_back(x), kedy ako ďalší prvok nastaví x s tým, že o pamäť sa stará sám (veľkosť si potom môžeme zistiť pomocou A.size())

Ako generická dátová štruktúra:

  vector<int> A;
  for (int i=0; i<10; i++){
    A.push_back(i);
  }
  for (int i=0; i<A.size(); i++){
    cout << A[i] << endl;     // alebo A.at(i)
  }

Štruktúra map

implementuje slovník, pričom zadáme dva typy: kľúč a hodnota

  map <string, string> zoznam;
  zoznam["Jozko Mrkvicka"] = "02/12345678";
  zoznam["Janko Hrasko"] = "02/87654321";
  if(zoznam.count("Jozko Mrkvicka") > 0) {
    cout << zoznam["Jozko Mrkvicka"] << endl;
  }
  // prejdenie vsetkych zaznamov v slovniku pomcou iteratora
  cout << "Vsetky zaznamy:" << endl;
  for(map <string, string>::iterator i=zoznam.begin();
      i!=zoznam.end(); i++) {
    // i->first je meno, i->second je cislo
    cout << i->first << " " << i->second << endl;
  }

Štruktúra dequeue

implementuje zásobník aj rad naraz (double-ended queue)

  deque <int> a;
  a.push_back(0);
  a.push_front(1);
  cout << a.back() << endl;
  cout << a.front() << endl;
  a.pop_back();
  a.pop_front();

Algoritmus na triedenie

v knižnici <algorithm>

//triedime normalne pole
int A[6] = {1, 4, 2, 8, 5, 7};
sort(A, A + 6);

//triedime vektor
vector <int> A;
sort(A.begin(), A.end());

//triedime podla nasej porovnavacej funkcie, napr. podla absolutnej hodnoty
struct cmp {
    bool operator()(int x, int y) { return abs(x) < abs(y); }
};
cmp c;
sort(A.begin(), A.end(), c);

Cvičenia 13

Na prednáške 22 nájdete ukážkový program pre lexikografický strom. Zmeňte ho tak, aby najskôr načítal zo súboru dict.txt zoznam anglických slov a uložil ich do stromu. Potom načíta od užívateľa nejaký reťazec a vypíše všetky slová, ktoré na tento reťazec začínajú. Napríklad pre reťazec all vypíše all allah allegiance allen alley alliance allied allow allowance allowed allowing allude allusion ally. Skúste pozmeniť alebo využiť funkcie printSubtree a find. Pozor, program predpokladá, že reťazce obsahujú iba veľké písmená anglickej abecedy. Malé písmena zo vstupu zmeníte na veľké funkciou toupper z knižnice cctype.

Skúste si vyriešiť ukážkový príklad B na skúšku, alebo aspoň jeho časť.

Napíšte funkciu, ktorá binárny strom upraví tak, že v dátovej časti vrcholov bude node * next ukazujúci na nasledujúci vrchol stromu v
- infixovom poradí
- prefixovom poradí

Naprogramujte funkciu, ktorá uprace lexikografický strom, t.j. uvoľní všetky vrcholy, ktoré svojom podstrome nemajú žiaden vrchol, kde isWord je pravdivé.

2013/14 Programovanie (1) v C/C++

Obsah

Zimný semester, úvodné informácie

Základné údaje

Ciele predmetu

Literatúra

Priebeh semestra

Celkové odporúčania

Zimný semester, pravidlá

Známkovanie

Stupnica

Rozcvičky

Domáce úlohy

Záverečný písomný test

Skúška

Opravné termíny

Opisovanie

Neprítomnosť

Možnosti pre pokročilých programátorov

Nepreberané črty jazykov C a C++

Zimný semester, test a skúška

Termíny

Záverečná písomka

Čo musíte, môžete a nemôžete

Príklady

Skúška pri počítači

Príklady

Hodnotenie

Opravné termíny

Ukážkové príklady na písomný test

Vzorové riešenia ukážkových príkladov na písomný test

Ukážkové príklady na skúšku pri počítači

Prvý príklad, verzia A

Prvý príklad, verzia B

Druhý príklad

Netbeans

Ako spustiť Netbeans v učebni

Základy práce v Netbeans

Práca v Netbeans s grafickou knižnicou SVGdraw

Práca s Netbeans na vlastnom počítači

SVGdraw

Vykresľovanie v SVG formáte

Animácie

Príkazy pre korytnačiu grafiku

Prednáška 1

Čo je programovanie

Algoritmus

Správnosť algoritmu

Program

Programátorské prostredie

Prvý program

Spúšťanie programu

Prvý grafický program

Cvičenia

Vykreslenie domčeka

Domček korytnačou grafikou

Zhrnutie

Organizačné poznámky

Prednáška 2

Premenné

Textový výpis a načítanie

Viac o príkaze cout

Viac o príkaze cin

Výrazy

Premenné

Aritmetické výrazy

Konštanty

Logické konštanty a výrazy

Vyhodnocovanie výrazov

Podmienka (if)

Vnorené podmienky

Upozornenie

Cyklus (for)

Vypisovanie čísiel

Vykreslenie náhodných kruhov

Organizačné poznámky

Cvičenia 1

Príklad 1

Príklad 2

Príklad 3