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.
Hlavné 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 prípadne výnimočne za počítačom. Ďalšou časťou cvičenia je precvičovanie príkladov k predchádzajúcim prednáškam.
Okrem toho sa každý týždeň konajú doplnkové 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. Na doplnkovom cvičení môže byť zadaná nepovinná opravná rozcvička k predchádzajúcej už obodovanej rozcvičke.
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. V prípade problémov doporučujeme navštíviť doplnkové cvičenia, alebo si dohodnúť konzultáciu. Môžete nám klásť tiež otázky 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 doplnkové 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 doplnkové 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 cvičeniach
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
- Na skúške úspešne odovzdať aspoň jeden z dvoch príkladov
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 hlavné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.
Niektoré rozcvičky môžu byť počítači, pričom odovzdávate program v rovnakom systéme ako domáce úlohy. Pri rozcvičkách pri počítači je zakázané komunikovať alebo zdieľať súbory so spolužiakmi či inými osobami.
Na doplnkovom cvičení môže byť zadaná nepovinná opravná rozcvička, body z ktorej nahrádzajú body z predchádzajúcej už obodovanej rozcvičky. Na opravnej rozcvičke ale môžete získať najviac 4 body z 5, aj keď ju máte úplne dobre.
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 programu k nejakej chybe. Počas opravovania váš program môžeme testovať aj na ďalších vstupoch. Dajte pozor na všetky pokyny uveden v zadaní (presný formát vstupu a výstupu, mená súborov a podobne).
- Ak váš program nebeží správne na testovacích vstupoch, určite nedostanete plný počet bodov, môžete však dostať čiastočné body, ak myšlienka vášho programu je správna.
- Ak váš program beží správne na testovacích vstupoch, nemáte zaručený plný počet bodov, lebo váš program stále môže obsahovať chybu, ktorú tieto vstupy neodhalili.
- Testovacie vstupy sú teda pomôcka, ktorá vám pomôže odhaliť aspoň niektoré problémy vášho programu.

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 koncom 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 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.
Na skúške budú úlohy automaticky testované podobne ako domáce úlohy. Aspoň jedna úloha musí správne prejsť cez všetky testy, inak má študent z daného termínu skúšky známku Fx.
Po skončení skúšky sa koná krátky ústny pohovor s vyučujúcimi, počas ktorého prediskutujeme programy, ktoré ste odovzdali a uzavrieme vašu známku.
Bližšie informácie o skúške poskytneme koncom semestra.

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 (s výnimkou webstránky predmetu) 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ť so ž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 hlavných 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Ú1, 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. Odporúčame tiež si preštudovať pravidlá predmetu.

Termíny

Písomný test

Riadny termín pondelok 14.12. o 14:00 v posluchárni F2
Opravný termín 11.1. o 14:00

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

piatok 8.1. H6 riadny termín
piatok 15.1. H6 riadny termín
1. opravný termín
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 miestnosťou, 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.

Príklady

Na skúške budete riešiť dva príklady za rovnaký počet bodov
- Nie sú rovnako ťažké, preto si dobre premyslite, ako si rozdelíte čas.
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.
- Predtým ako začnete programovať, si poriadne rozmyslite, aké dátové štruktúry (polia, matice, struct-y a pod.) chcete v programe použiť.
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 resp. na testovači 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 veľmi dôležité, aby sa program dal skompilovať (v štandardnom prostredí) a aby správne fungoval na všetkých vstupoch spĺňajúcich podmienky v zadaní.
V druhej úlohe budeme jednotlivé funkcie hodnotiť zvlášť, takže môžete získať čiastočné body, ak ste niekoľko funkcií napísali správne.
Na hodnotenie môže mať menší vplyv aj úprava 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.
Aby ste mali šancu úspešne ukončiť predmet, aspoň jeden z príkladov vám musí prejsť všetky testy na testovači
- Túto podmienku nebudeme považovať za splnenú, ak váš program nerieši zadanú úlohu (t.j. jeho myšlienka nie je v zásade správna)
- Podmienku však považujeme za splnenú, ak váš program prejde všetky vstupy, má v zásade správnu myšlienku, ale nedostane plný počet bodov napríklad kvôli chýbajúcemu uvoľneniu pamäte, menšej chybe, ktorá sa neprejavila na daných vstupoch a pod.

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.
- Rozhodnúť o účasti sa musíte predtým, ako rozdáme zadania
- Toto platí aj pre študentov, ktorí získali aspoň polovicu bodov na teste pre pokročilých a rozhodujú sa, či prísť na riadny termín testu
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 píšete opravnú 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

Niektoré ukážkové príklady na skúšku sú k dispozícii na testovači, môžete si ich v rámci tréningu vyriešiť a odovzdať.

Prvý príklad

Simulácia hry podobnej na človeče
Vyhodnocovanie pretekov
DÚ9 je tiež bývalý skúškový príklad. Ak ste ju nemali správne, skúste si ju ešte odovzdať
Rozcvička 8 a Opravná rozcvička 8 sú síce ľahšie, ako typický prvý príklad na skúške, ale môžete si na nich precvičiť aspoň základy ako sú načítanie, výpis a práca s pamäťou

Druhý príklad

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 Projects, 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 (alebo klávesa F11 alebo ikonka kladivka na lište), program sa skompiluje. Prípadné chyby sa objavia v dolnej časti okna.
V menu Run zvoľte Run main project (alebo klávesa F6 alebo ikonka zelenej šípky na lište), 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 8.0.2., mala by však postačovať aj iná verzia)
Kompilá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/80/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 akom 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 alebo doprava 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

DÚ1 už zverejnená
Zajtra druhá prednáška
V stredu prvé cvičenia
- Budete potrebovať prihlasovacie meno a heslo do AIS2 na prihlásenie v učebni
- Skúste odovzdať DÚ1 (heslo dostanete na cvičení)
Do piatka sa prihlásiť na test pre pokročilých
V piatok nebudú doplnkové cvičenia kvôli dekanskému voľnu (imatrikulácie)
Do pondelka odovzdať DÚ1
Budúci týždeň bežný rozvrh, vrátane oboch prednášok, cvičení a prvej rozcvičky
Budúci pondelok 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 tiež uložíme do 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

Zajtra prvé cvičenia
- Budete potrebovať prihlasovacie meno a heslo do AIS2 na prihlásenie v učebni
- Skúste odovzdať DÚ1 (heslo dostanete na cvičení)
V piatok nebudú doplnkové cvičenia kvôli dekanskému voľnu (imatrikulácie)
Do pondelka odovzdať DÚ1
Budúci týždeň bežný rozvrh, vrátane oboch prednášok, cvičení a prvej rozcvičky
Budúci pondelok test pre pokročilých, prihlasovanie do piatku

Cvičenia 1

Cieľom prvých cvičení je vyskúšať si prostredie Netbeans a písanie jednoduchých textových aj grafických programov. Podobné programy budete písať budúci týždeň na rozcvičke, takže odporúčame si priniesť papier s poznámkami z prvých dvoch prednášok. Ak nestihnete na cvičení spraviť všetky príklady, môžete si zvyšné skúsiť naprogramovať doma, čo je obzvlášť vhodné cvičenie pre menej skúsených programátorov.

Príklad 1: Hello world

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

Príklad 2: odovzdávanie domácich úloh

Prihláste sa na odovzdávací server, zmeňte si heslo
Odovzdajte program Hello world ako "riešenie" prvej domácej úlohy.
- Testovač si samozrejme všimne, že váš program nie je správny. Pozrite si, ako vám zobrazí chybu.

Príklad 3: vstup, výstup, podmienka if

Napíšte program, ktorý načíta dve čísla a vypíše väčšie z nich.
Skompilujte ho a vyskúšajte na niekoľkých vstupoch, či funguje správne (toto treba spraviť s každým programátorským zadaním)

Príklad 4: cyklus

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

1 na druhu je 1
2 na druhu je 4
3 na druhu je 9
...

Príklad 5: práca s grafickou knižnicou

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

Príklad 6: DÚ1

Pokúste sa správne vyriešiť a odovzdať prvú domácu úlohu.
Pozor: Vo všeobecnosti nebudeme ďalšie domáce úlohy riešiť na hlavných cvičeniach, môžete však na nich pracovať na doplnkových cvičeniach.
Otázky k úlohám sa môžete pýtať e-mailom, doplnkových cvičeniach, na dohodnutých konzultačných hodinách, v prípade krátkych otázok aj tesne pred začiatkom alebo po konci prednášky alebo hlavného cvičenia.

Príklad 7: grafická knižnica, korytnačka, cyklus

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.
Vytvorený obrázok si pozrite programom Firefox, aby ste videli animáciu korytnačky

Príklad 8: grafická knižnica, výpočty

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;

Príklad 9: ešte raz grafická knižnica a cyklus

Š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 3

Úvod

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ý cyklus while. 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

Dnes o 22:00 termín odovzdania DÚ1. Ak máte problémy, dajte nám vedieť.
Zajtra zverejnenie DÚ2 a PDÚ1.
V stredu na cvičeniach prvá rozcvička.
V stredu o 9:50 (cez cvičenia) test pre pokročilých (pozor, zmena času). V prípade záujmu o test sa ešte dnes môžete hlásiť B.Brejovej e-mailom.

Prednáška 4

Funkcie

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á 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á hodnota 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 s intervalmi

Máme dané dva intervaly [a,b] a [c,d] a chceme buď vypísať ich prienik, alebo správu, že sú disjunktné.

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

DÚ2 je zverejnená, odovzdávajte do budúceho pondelka 22:00
PDÚ1 (pokročilá DǓ) je zverejnená, odovzdávajte do 14.10. (ak chcete riešiť pokročilé miesto bežných DÚ a nebudete písať test pre pokročilých, kontaktujte vyučujúcich)
Výsledky DÚ a rozcvičiek budete časom vidieť v odovzdávacom systéme.
Zajtra cvičenia s prvou rozcvičkou, v piatok doplnkové cvičenia s opravnou rozcvičkou.
Test pre pokročilých zajtra o 9:50 v M-213, len pre prihlásených študentov.

Organizačné poznámky k štúdiu

Do nedele 5.10. je možnosť meniť v AISe zapísané predmety. Budúci týždeň je potrebné si prípadné zmeny v zápise dať potvrdiť na študijnom (v období od 6.10. do 10.10.2014). Pred koncom tejto doby bývajú na študijnom dlhé rady, choďte čím skôr.
Ak ste robili nejaké výraznejšie zmeny oproti odporúčanému plánu, pre istotu si to poriadne skontrolujte a ak si nie ste istí či máte všetko v poriadku, pošlite mi mail.

Cvičenia 2

Úlohou tohto cvičenia je precvičiť si logické výrazy a podmienky, použitie cyklov a funkcií.

Logické výrazy a podmienky

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 tri celé čísla a vypíše, či môžu byť stranami jedného trojuholníka.

Cykly: 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 na začiatku programu načítajte od užívateľa.

Čí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 SVG obrázku 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 programe použite túto funkciu na vykreslenie domčekov rôznej farby na niekoľkých miestach na obrázku.

Prednáška 5

Organizačné poznámky

Nezabudnite dnes do 22:00 odovzdať DÚ2, v utorok ráno sa objaví DÚ3.
Tento týždeň: utorok prednáška, streda cvičenia s rozcvičkou, piatok doplnkové cvičenie.
Nezabudnite si prípadné zmeny v zápise dať tento týždeň potvrdiť na študijnom.

Š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ľkokrát sa jednotlivé čísla na vstupe vyskytli. Mohli by sme to riešiť takto:

Pre každú hodnotu 0...9 si vytvoríme jednu premennú (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) { // test, či je číslo z požadovaného rozsahu
            p[x]++;             // zvýšime počítdlo pre hodnotu x
        }
    }

    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

#include <iostream>
using namespace std;

int main(void) {
    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;  // ukončíme funkciu main a tým aj program
    }
   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 tu 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äti 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];

Polia sa tiež nedajú porovnávať pomocou operátora ==. Podmienku if (a==b) cout << "Ok";. síce skompilujete, ale nikdy to nebude pravda – neporovná sa obsah poľa, ale niečo úplne iné (adresy polí v pamäti). Treba opäť porovnávať prvok po prvku.

  bool rovne = true;
  for (i = 0; i < 10; i++) { 
      rovne = rovne && a[i] == b[i]; 
  }
  if (rovne) cout << "Rovnaju sa" << endl;

Ten istý kúsok programu môžeme napísať napr. aj takto:

  bool rovne = true;
  for (i = 0; i < 10; i++) { 
      if(a[i] != b[i]) {
          rovne = false;
          break;
      }
  }
  if (rovne) cout << "Rovnaju sa" << endl;

Kreslíme padajúce kruhy

Chceme vykresliť animáciu padajúcich kruhov

Viď príkazy na animáciu v knižnici SVGdraw
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);
    }
}

Pomocou struct vytvoríme nový dátový typ kruh, ktorý má niekoľko zložiek x, y,...
- v programe vyššie sú všetky typu int, mohli by však byť aj rôznych typov (napr. struct kruh { double x,y; int id; bool visible; };)
Môžeme vytvárať premenné typu kruh aj polia kruhov, napr. kruh jedenKruh; kruh poleKruhov[10];
K položkám kruhu pristupujeme pomocou bodky, napr. jedenKruh.x = 4; if(polekruhov[2].visible) { ... }

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

Ďalšie príklady na prácu s poľom

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

Načítajte pole čísel, náhodne ich premiešajte a zase vypíšte.

Zhrnutie

Pole je tabuľka hodnôt. V poli dĺžky n máme hodnoty p[0], p[1], ..., p[n-1]
Kopírovanie a porovnávanie polí si musíme naprogramovať
C resp. C++ nekontrolujú, či index nie je mimo rozsahu poľa
Súvisiace informácie o nejakom prvku môžeme spojiť do štruktúry pomocou struct

Prednáška 6

Organizačné poznámky

Je zverejnená DU3 aj s bonusovou časťou. Termín oboch je 12.10. do 22:00.

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. Ďalší týždeň potom 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);
}

Cvičenia 3

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 3

  #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 7

Organizačné poznámky

DÚ3 do dnes, pokročilá DÚ1 do stredy
V piatok 16.10. od 13:00 v H6 školské kolo programátorskej súťaže ACM.

Na konci stránok k starším cvičeniam boli pridané vzorové riešenia niektorých príkladov
Pozor, dostávame sa do častí semestra s ťažšou učebnou látkou, budúci týždeň začína rekurzia
Nezačínajte robiť DÚ až v pondelok, radšej príďte na doplnkové cvičenia v piatok

Vyhľadávanie prvkov poľa

Chceme zistiť, či pole obsahuje prvok zadanej hodnoty.

Musíme prejsť celé pole, lebo nevieme, kde sa prvok môže nachádzať.
Tento algoritmus sa nazýva lineárne vyhľadávanie

/* Funkcia find vráti index výskytu prvku x
 * v poli a. Ak sa x v poli nevyskytuje, vráti -1.
 * Hodnota n určuje počet prvkov poľa. */
int find(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é.
Ale neexistuje lepšie riešenie?

Binárne vyhľadávanie

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

Ak sa pozrieme v utriedenom poli na nejaký prvok a[i], tak v intervale a[0],...,a[i-1] sú čísla veľkosti nanajvýš a[i] a v intervale a[i+1]...a[n-1] sú čísla veľkosti aspoň A[i].
Keď teda hľadáme prvok x, tak po jednom nahliadnutí do poľa vieme
- buď priamo povedať, že ten prvok sa tam nachádza - ak sme trafili pozíciu i takú, že x=A[i]
- vyhodiť (t.j. ďalej neuvažovať) časť poľa v intervale (i+1)..(N-1) - ak sme trafili pozíciu i takú, že x<A[i]
- vyhodiť (t.j. ďalej neuvažovať) časť poľa v intervale 0..(i-1) - ak sme trafili pozíciu i takú, že x>A[i]

V utriedenom poli teda môžeme vyhľadávať nasledovne:

pamätáme si ľavý a pravý okraj intervalu, kde ešte môže byť hľadaný prvok
vyberieme nejaký prvok A[index] z tohoto intervalu a patrične interval skrátime
ak už je interval zlý (t.j. pravý a ľavý kraj sú naopak), tak skončíme

int find(int a[], int n, int x) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int index = (left + right) / 2;
        if (a[index] == x) {
            return index;
        }
        else if (a[index] < x) {
            left = index + 1;
        }
        else {
            right = index - 1;
        }
    }
    return -1;
}

Ako zvoliť hodnotu index?

Ak by sme zvolili za index hodnotu left, dostali by sme niečo veľmi podobné na lineárne vyhľadávanie
Hlavný rozdiel je, že v prípade, že nájdeme prvok poľa, ktorý je väčší ako hľadané x, tak zastavíme a odpovieme, že prvok tam nie je.

int a[7]={2,5,41,68,72,80,100}
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
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

V binárnom vyhľadávaní preto používame ako index stredný prvok intervalu, teda index=(left+right)/2
Tým dosiahneme, že v každom kroku zahodíme polovicu poľa.

int a[7]={2,5,41,68,72,80,100}
x=41
   left=0 right=6: index=3; A[index]>x (68>41)
   left=0 right=2; index=1; A[index]<x (5<41)
   left=2 right=2; index=2; A[index]=x -> return 2
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

Intuitívne máme pocit, že binárne vyhľadávanie je lepšie, ako lineárne.

Zložitosť algoritmu

Ako sme videli napríklad pri triedení a vyhľadávaní, jednu úlohu môžeme často riešiť viacerými spôsobmi. Intuitívne máme o niektorých pocit, že sú lepšie ako iné. Pozrime sa, prečo sú niektoré riešenia lepšie a ako môžeme niečo také odhadovať.

Časová zložitosť lineárneho vyhľadávania

Často nás zaujíma, ako rýchlo nám program bude bežať. Väčšinou táto rýchlosť nejako závisí od vstupných dát. Iste bude kratšie trvať triedenie trojprvkového poľa ako poľa s milión prvkami. Časovú zložitosť teda budeme odhadovať v závislosti od veľkosti vstupu.

Pre niektoré programy môžeme spočítať počet operácií, ktoré program vykoná. Avšak tento počet môže závisieť od konkrétneho vstupu.

Ukážme si túto metódu pre lineárne vyhľadávanie v neutriedenom poli

int find(int a[], int n, int x) {
    for (int i = 0; i < n; i++) {
        if (a[i] == x) return i;
    }
    return -1;
}

Najmenej operácií spravíme, ak x je v a[0]
Vtedy spravíme 4 kroky: i=0, i<n, a[i]==x, return i (závisí aj od toho, čo presne považujeme za "jeden krok")
Najviac operácií spravíme, ak sa x v poli nenachádza
Vtedy spravíme raz i=0, (n+1) krát i<n, n krát i++, n krát a[i]==x, raz return -1, spolu 3n+3 krokov
Celkový počet krokov bude teda teda niečo medzi 4 a 3n+3

Vo väčších programoch však toto rozmedzie nie je jednoduché vypočítať.

Preto uvažujeme väčšinou iba najhorší prípad, ktorý môže nastať
Okrem toho nás nezaujímajú presné čísla, ale iba akýsi odhad (približná funkcia) závislá od vstupu.
Pri lineárnom vyhľadávaní je v najhoršom prípade počet krokov lineárna funkcia od n, vravíme teda, že tento algoritmus má lineárnu zložitosť, značíme O(n)
Presnú definíciu O uvidíte budúci rok na predmete Algoritmy a dátové štruktúry

Časová zložitosť binárneho vyhľadávania

Najhorší možný scenár pre danú veľkosť vstupu n nastane, keď prvok nájdeme až v poslednom kroku alebo v poli nebude vôbec.
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 polovicu menšie, až kým nemáme pole veľkosti 1. Potom už prvok nájdeme alebo v ďalšom kroku povieme, že tam nie je.
Akú zložitosť bude mať tento algoritmus?
- 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 toto číslo bez poslednej cifry.
- Počet krokov, ktoré potrebujeme, je teda zhruba počet cifier n v dvojkovej sústave, č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} .
Vravíme teda, že zložitosť binárneho vyhľadávania je logaritmická, značíme O(log n)
Logaritmus rastie pre veľké n oveľa pomalšie ako lineárna funkcia, čiže binárne vyhľadávanie považujeme za efektívnejší algoritmus ako lineárne vyhľadávanie
- pozor, neplatí to však pre každý vstup, iba pre porovnanie najhorších prípadov pre dosť veľké n

Časová zložitosť triedenia vkladaním

Triedenia vkladaním (Insertion sort) z minulej prednášky

Pripomíname ideu: prvých i prvkov máme utriedených, prvok a[i] sa snažíme vložiť na správne miesto
Na to musíme posunúť všetky väčšie prvky o jedna doprava, aby sme mu spravili miesto

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 najhoršom prípade pre dané i bude a[i] menšie ako všetky doteraz utriedené prvky a teda while cyklus bude bežať i krát
Ak je pole na začiatku usporiadané naopak, t.j. od najväčšieho prvku po najmenší, tento najhorší prípad nastane pri každej hodnote i
Teraz si už iba spočítame: pre i=1 posúvame 1 prvok, pre i=2 dva prvky, ..., pre i=n-1 posúvame n-1 prvkov
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 1+2+...+(n-1)=\frac{n(n-1)}{2}=\frac{n^2}{2}-\frac{n}{2}} .
Zložitosť tohoto triedenia bude teda kvadratická, čiž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 O(n^2)}

Bude sa však správať rovnako (kvadraticky) na všetkých vstupoch? Čo ak dostaneme na vstupe pole už správne utriedené?

Ostatné triedenia z minule prednášky (výberom a bublinkové) a majú tiež v najhoršom prípade kvadratickú zložitosť

Premyslite si prečo
Ako dlho im to potrvá v najlepšom prípade?

Existujú však aj triedenia s časovou zložitosťou O(n log n), ako uvidíme budúci týždeň

Cvičenie:

Na vstupe máme n čísel usporiadaných od najmenšieho po najväčšie a číslo x, chceme zistiť, či sa x nachádza medzi n číslami
Načítame čísla do poľa a spustíme lineárne alebo binárne vyhľadávanie
Aká bude časová zložitosť týchto dvoch verzií programu?
Čo ak nechceme vyhľadávať jednu hodnotu x, ale m rôznych hodnôt?
Čo ak nie sú čísla na vstupe utriedené a pred binárnym vyhľadávaním musíme najskôr triediť?

Pamäťová zložitosť

Ďalší bežný dôvod, prečo nejaký algoritmus môže byť lepší ako iný je, že potrebuje na svoju činnosť menšiu pamäť. 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 v poli.
Budeme zisťovať maximum priebežne počas načítavania vstupu a pamätať si ho v jednej premennej.

Na prvý spôsob si potrebujeme zapamätať pole čísel veľkosti n a ešte nejaké pomocné premenné k tomu. Pre druhý spôsob (priebežné počítanie) si potrebujeme pamätať iba zopár pomocných premenných. Zjavne teda pre nejaké väčšie n bude druhý spôsob potrebovať oveľa menšiu pamäť.

Znaky

Doteraz sme pracovali iba s číselnými dátami, ale pri programovaní často pracujeme z reťazcami (textami).

Reťazce budú na ďalšej prednáške, dnes si ukážeme, ako pracovať s ich jednotlivými súčasťami, znakmi (písmená, čísla, medzery,...)

Znakové konštanty sa zapisujú v apostrofoch, napr. 'A', '1', ' ' a pod.
Znakové premenné sú typu char, z anglického character. Ich veľkosť je spravidla 1 bajt, t.j. 8 bitov.

Znaky majú svoje kódy uvedené v tabuľke ASCII. Najbežnejšie sa budeme stretávať s týmito:

48...57: '0'...'9'
65...90: 'A'...'Z'
97...122: 'a'...'z'
32: medzera ' '
9: tabulátor '\t'
10: koniec riadku '\n'
0: špeciálny nulový znak (uvidíme nabudúce) '\0'

Poznámky

bežné znaky z US klávesnice sú v rozsahu 0..127 (7 bitov)
nakoľko char je 8-bitový, môže ešte nadobúdať hodnoty -1 ... -128 alebo 128..255 podľa kompilátora
moderný softvér väčšinou namiesto klasických 8-bitových znakov používa Unicode, aby sa dali reprezentovať aj rôzne špeciálne symboly, znaky s diakritikou, jazyky nepoužívajúce latinku a pod.
na tomto predmete si vystačíme s klasickými znakmi v rozsahu 0..127
znaky sa dajú zapísať aj pomocou ich kódu v osmičkovej alebo šestnástkovej sústave: '\101' a '\x41' reprezentujú znak s kódom 65, t.j. 'A'.

Do premennej typu char môžeme 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ôžeme 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.

Pri čítaní zo vstupu pomocou cin do premennej typu char sa preskakujú tzv. biele znaky (napr. medzera, tabulátor, koniec riadku).

Toto nie je vždy žiadúce a preto môžeme použiť 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;
}

Pretypovanie

Znakové premenné teda ukladajú kódy jednotlivých znakov, čo sú celé čísla. 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. pretypovanie, 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í)

Nasledujúci program spúšťa hru "Hádaj číslo" a po uhádnutí ponúkne 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) {    
    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

Predchádzajúci program riešil len dve možné odpovede, 'Y' alebo 'N'
Ak by možností bolo viac, mali by sme dlhú a komplikovanú sériu príkazov if, else
Namiesto toho sa dá použiť používame príkaz switch, ktorý podľa hodnoty výrazu pokračuje jednou z viacerých vetiev.

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; break;
}

Vo všeobecnosti obsahuje 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 z prípadov, pokračuje časťou príkazyi
- Ak sa nezhoduje a máme vetvu default, pokračuje sa časťou prikazyd
- Ak nie je vetva default, pokračuje sa za koncom switch bloku.
Pozor: Na rozdiel od pascalovského case, vykonávanie nekončí vykonaním posledného príkazu v prikazyi, ale pokračuje ďalej, kým nie je prerušené príkazom break.
- Toto je častá chyba pri použití príkazu switch

#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

V príklade Hádaj číslo sme použili na ukončenie cyklu while premennú pokracuj. Namiesto toho by sme mohli urobiť cyklus nekonečný a v prípade odpovede 'N' cyklus prerušiť príkazom break.

Ak by break bol použitý s podmienkou, všetko by fungovalo: while (true) { ... if (c=='N') { break; } }
Ak však dáme break do príkazu switch, preruší vykonávanie ďalších vetiev switch-u a nie while while (true) { ... switch (c) { ... case 'N': break; } }
- Program by teda neskončil nikdy.
- 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.

Zhrnutie

Binárne vyhľadávanie rýchlo hľadá v utriedenom poli určitú hodnotu
Pomocou odhadovania časovej zložitosti môžeme rýchlo porovnať dva algoritmy, viac detailov budúci rok
Premenná typu char obsahuje jeden znak uložený ako celočíselný kód
Pomocou premenných typu char môžeme spraviť jednoduchú kontrolu formátu vstupu
Príkaz switch umožňuje špecifikovať viacero vetiev výpočtu, ale nezabudnite na break

Prednáška 8

Organizačné poznámky

Na DÚ3 sa vyskytlo opisovanie.
- Pripomíname, že všetci zúčastnení (aj ten, kto dal opísať) dostávajú za opísanú DÚ -5 bodov.
- Opakované prípady opisovania podstúpime na riešenie disciplinárnej komisii fakulty.
Pokročilú DÚ1 odovzdávajte do zajtra do 22:00
Zadania DÚ4 sa objavia dnes, PDÚ2 koncom týždňa
Budúci týždeň začneme preberať rekurziu, dôležité učivo

Z minulej prednášky

Vďaka znakom môžeme spraviť kontrolu toho, čo 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, znaky uloží do poľa a, dĺžku textu 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ý v poli ako postupnosť znakov (char) 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 width-n 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 ste 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 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 na 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. */

    /* 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;  /* index prveho pismena 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];
    A[0] = 0;

    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ď. a pomocou cin a cout môžeme reťazce načítavať a vypisovať.
Ďalšie funkcie si vieme naprogramovať aj sami, zvyčajne jednoduchá práca s poľom

Cvičenia 4

Cieľom tohto cvičenia je precvičiť si prácu so znakmi, reťazcami.

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 9

Organizačné poznámky

DÚ4 do zajtra (posunutý termín), zadania DÚ5 sa objavia zajtra
PDÚ2 do 4.11.
Dnes začíname rekurziu, neváhajte dôjsť na doplnkové cvičenia
Pozor na úpravu v odovzdaných úlohách
Pozor na neskoré odovzdania (odovzdávať môžete aj po termíne, ale nebude to brané do úvahy).
- Ak vám vážne okolnosti znemožnia odovzdať načas, ospravedlňte sa.
- Ale hlavne nenechávajte úlohu na poslednú chvíľu.

Klasické ú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 pozrieme na „klasické“ príklady algoritmov využívajúcich rekurziu.

Výpočet faktoriálu

Faktoriál prirodzeného čísla n značíme n! a je to súčin všetkých celých čísel od 1 po n. Pre úplnosť 0! definujeme ako 1.

Výpočet pomocou cyklu z prednášky 3:

int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result = result * i;
    }
    return result;
}

Rekurzívna definícia faktoriálu: 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! = \left\{\begin{array}{ll} 1 & \mathrm{ak~} n<2 \\ n \cdot (n-1)! & \mathrm{inak} \\ \end{array}\right.}

Túto matematickú definíciu môžeme priamočiaro prepísať do rekurzívnej funkcie:

int factorial(int n) {
    if (n < 2) return 1;
    else return n * factorial(n-1);
}

Aby sa nám rekurzia nezacyklila, mali by sme dodržiavať nasledujúce zásady:

Rekurzívna funkcia musí obsahovať vetvu pre triviálny prípad niektorého vstupu. Táto vetva nebude obsahovať rekurzívne volanie funkcie, ktorú práve definujeme.
Rekurzívne volanie funkcie by malo mať vhodne redukovaný niektorý vstup, aby sme sa časom dopracovali k triviálnemu prípadu.

Najväčší spoločný deliteľ (Euklidov algoritmus)

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

Euklidov algoritmus z prednášky 3 bol založený na rovnosti gcd(a,b) = gcd(b, a mod b)
Tú sme použili v cykle:

int gcd(int a, int b) {
    while(b != 0) {
        int x = a % b;
        a = b;
        b = x;
    }
    return a;
}

Avšak opäť to isté môžeme ešte kratšie a elegantnejšie napísať rekurziou:

int gcd(int a, int b) {
   if (b == 0) return a;
   else return gcd(b, a % b);
}

Fibonacciho čísla

A nemôžeme vynechať obľúbený rekurzívny príklad - Fibonacciho čísla, ktoré sme videli na prednáške 4. Aj 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ívnu funkciu jednoducho:

int fib(int n){
    if (n<2) return 1;
    else return fib(n-1)+fib(n-2);
}

Toto je opäť krajšie ako nerekurzívna verzia:

int fib(int n) {
    int f = 1;     // Cislo F(i) 
    int oldF = 1;  // 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;
}

Binárne vyhľadávanie

Aj binárne vyhľadávanie prvku v utriedenom poli z prednášky 7 sa do sprehľadní v rekurzívnom zápise.

Pôvodná nerekurzívna funkcia vrátila polohu prvku x v poli a alebo hodnotou -1, ak sa tam nenachádzal:

int find(int a[], int n, int x) {
    int left = 0, right = n - 1;
    while (left <= right) {
        int index = (left + right) / 2;
        if (a[index] == x) return index;
        else if (a[index] < x) left = index + 1;
        else right = index - 1;
    }
    return -1;
}

V rekurzívnej verzii si okraje aktuálneho úseku poľa si v rekurzii posielame ako parametre:

int find(int a[], int left, int right, int x) {
    if (left > right) return -1;
    int index = (left + right) / 2;
    if (a[index] == x) return index;
    else if (a[index] < x) return find(a, index+1, right, x);
    else return find(a, left, index - 1, x);
}

Ak chceme vyhľadať x v poli a s n prvkami, voláme find(a, 0, n-1, x).

Na zamyslenie:

Táto funkcia má dva triviálne (nerekurzívne) prípady. Ktoré?
Aká veličina klesá v každom rekurzívnom volaní?

Tu je ešte trochu iná verzia binárneho vyhľadávania s niekoľkými rozdielmi:

vraciame iba či sa x nachádza v poli alebo nie (dalo by sa rozšíriť aj na index)
pri porovnávaní x a a[index] rozlišujeme iba dva prípady, nie tri
končíme pri intervale dĺžky 1, nie 0

bool contains (int a[], int left, int right, int x){
    if (left == right) return (a[left] == x);
    int index = (left + right) / 2;
    if (x <= a[index]) return contains(a, left, index, x);
    else return contains(a, index+1, right, x);
}

int main(void) {
  const int n = 9;
  int a[n]={1,5,7,12,45,55,72,95,103};
  cout << contains(a, 0, n-1, 467) << endl;
  cout << find(a, 0, n-1, 467) << endl;
}

Zhrnutie

Pri rekurzii vyjadríme riešenie nejakej úlohy pomocou riešenia jednej alebo viacerých úloh toho istého typu, ale s menším vstupom plus ďalšie potrebné nerekurzívne výpočty

výpočet n! vyjadríme pomocou výpočtu (n-1)! a násobenia
výpočet gcd(a, b) vyjadríme pomocou výpočtu gcd(b, a % b)
výpočet F[n] vyjadríme pomocou výpočtu F[n-1] a F[n-2]
binárne vyhľadávanie v dlhšom intervale vyjadríme pomocou binárneho vyhľadávania v kratšom intervale

Všimnite si, že občas musíme zoznam parametrov nejakej funkcie rozšíriť pre potreby rekurzie

napr. funkcia find by prirodzene dostávala pole a, dĺžku n a hľadaný prvok, ale kvôli rekurzii potrebuje ľavý a pravý okraj
pre pohodlie užívateľa môžeme pridať pomocnú funkciu (wrapper):

int find(int a[], int n, int x) {
  return find(a, 0, n-1, x);
}

Viac o rekurzii

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 viac krokov). 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);
}

Rekurzia pomocou zásobníka - ako je rekurzia implementovaná

O rekurzívne volania sa stará zásobník volaní (call stack)

Ide o všeobecnú štruktúru potrebnú aj v nerekurzívnych programoch, ktoré volajú funkcie
Po zavolaní nejakej funkcie f sa pre ňu vytvorí na zásobníku záznam, ktorý obsahuje všetky lokálne premenné a argumenty funkcie
Keď potom z funkcie f zavoláme nejakú funkciu g (pričom v rekurzii môže byť aj f=g), tak sa vytvorí nový záznam pre g. Navyše v zázname pre f si uložíme aj to, v ktorom kroku sme prestali s výpočtom, aby sme vedeli správne pokračovať
Po skončení výpočtu funkcie g sa jej záznam zruší zo zásobníka. Vrátime k záznamu pre funkciu f a pokračujeme vo výpočte so správnymi hodnotami všetkých premenných a od správneho miesta.

Záznamy v zásobníku si môžeme predstaviť uložené v stĺpci jeden nad druhým

vrchný záznam je aktuálny, pre funkciu, ktorá sa vykonáva
pod ním je záznam pre funkciu, ktorá ju volala atď
na spodku je záznam pre funkciu main

Teraz si môžeme jednoduchý zásobník odsimulovať napríklad na výpočte faktoriálu.

int factorial(int n) {
    if (n < 2) return 1;
    else return n * factorial(n-1);
}

Zložitejšie príklady rekurzie

Každý z predchádzajúcich príkladov sme vedeli pomerne jednoducho zapísať aj bez rekurzie, aj keď rekurzívny výpočet bol často prehľadnejší, zrozumiteľnejší, kratší a krajší.

Ukážeme si však aj príklady, ktoré by sa bez rekurzie písali obtiažne (aj keď ako si neskôr ukážeme, rekurzia sa dá vždy odstrániť, v najhoršom prípade simuláciou zásobníka). Takéto príklady, kde rekurzia veľmi pomáha, uvidíme na zvyšku dnešnej prednášky, ale aj na dvoch ďalších a k rekurzii sa vrátime aj neskôr v semestri a samozrejme na ďalších predmetoch.

Fraktály

Fraktály sú útvary, ktorých časti na rôznych úrovniach zväčšenia sa podobajú na celý útvar. Mnohé fraktály vieme definovať a vykresliť pomocou jednoduchej rekurzie.

Kochova krivka stupňa 3

Príkladom fraktálu je Kochova krivka. Ako vzniká?

Predstavme si úsečku, ktorá meria d centimetrov.
Spravíme s ňou nasledujúcu transformáciu:
- Úsečka sa rozdelí na tretiny a nad strednou tretinou sa zostrojí rovnostranný trojuholník. Základňa trojuholníka v krivke nebude.
- Dostávame tak útvar pozostávajúci zo štyroch úsečiek s dĺžkou d/3
Tú istú tranformáciu môžeme teraz spraviť na každej zo štyroch nových úsečiek, t.j. dostávame 16 úsečiek dĺžky d/9
Takéto transformácie môžeme robiť do nekončna

Druhá možnosť je popísať krivku pomocou dvoch parametrov: dĺžka d a stupeň n

Kochova krivka stupňa 0 je úsečka dĺžky d
Kochova krivka stupňa n pozostáva zo štyroch kriviek stupňa n-1 a dĺžky n/3
- na presný popis umiestnenia a natočenia týchto kriviek nižšieho stupňa by sme mohli použiť korytnačiu grafiku, čo máme spravené vo funkcii nižšie.

 
#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.turnRight(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();
}

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ú okolo každého podvýrazu
Príklady výrazov:
- 99
- (12+13)
- (((12-5)+7)-(6+8))
Výrazy uvažované v tomto probléme teda môžeme definovať takto:
- desiatkový zápis celého nezáporného čísla je výraz
- ak A a B sú výrazy a Z je znamienko + alebo -, tak reťazec (AZB) je tiež výraz
- nič iné výraz nie je

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

Začneme hľadaním polohy správneho znamienka Z:

int najdiZnamienko(char str[]) {
    // vo vyraze tvaru (vyrazZvyraz najde polohu znamienka Z
    int poc=0; // pocet otvorenych zatvoriek
    for (int i=1; i<strlen(str)-1; i++) { //preskocime prvu lavu zatvorku
        if (str[i]=='(') poc++;
        else if (str[i]==')') poc--;
        else if (poc==0 && (str[i] == '+' || str[i]=='-')) return i;
    }
    return -1;
}

Čo bude triviálny prípad vyhodnocovania výrazu?

keď je výraz číslo, t.j. nezačína zátvorkou

Potom vyhodnocovanie výrazu može pracovať nasledovne:

int vyhodnotVyraz(char str[]){
    if (str[0]!='(') return vyhodnotCislo(str);
    else {
        char s[100];
        int poz = najdiZnamienko(str);

        strCopy(str, s, 1, poz-1);      // od 1 po pozíciu pred znamienkom (pozícia 0 je '(' )
        int hodnota1 = vyhodnotVyraz(s);
        strCopy(str, s, poz+1, strlen(str)-2); // od pozície po znamienku po predposledný znak str (posledný znak - strlen()-1 je ')' )
        int hodnota2 = vyhodnotVyraz(s);

        switch (str[poz]){
            case '+': return hodnota1+hodnota2;
            case '-': return hodnota1-hodnota2;
        }
        return 0;
    }    
}

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 od najväčšieho po najmenší.
Ú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)
}

Drobnosť na záver: chvostová rekurzia

Chvostová rekurzia je rekurzia, kde je rekurzívne volanie ako úplne posledná akcia vo volajúcej funkcii, ako napr. pri výpočte gcd

int gcd(int a, int b) {
   if (b == 0) return a;
   else return gcd(b, a % b);
}

Ale aj v binárnom vyhľadávaní rekurzia volala až úplne na koniec:

bool contains (int a[], int left, int right, int x){
    if (left == right) return (a[left] == x);
    int index = (left + right) / 2;
    if (x <= a[index]) return contains(a, left, index, x);
    else return contains(a, index+1, right, x);
}

Dobrý kompilátor dokáže z takejto rekurzívnej funkcie vytvoriť nerekurzívnu.

Avšak napr. rekurzívny faktoriál nepoužíval chovostovú rekurziu, lebo výsledok rekurzie bolo ešte treba vynásobiť n:

int factorial(int n) {
    if (n < 2) return 1;
    else return n * factorial(n-1);
}

Dal by sa však zapísať aj chvostovou rekurziou, s použitím pomocného parametra:

/* tato funkcia spocita x * (n!) */
int xTimesFactorial(int n, int x) {
  if(n<2) return x;
  else return xTimesFactorial(n-1, n*x);
}

int factorial(int n) {
  return xTimesFactorial(n, 1);
}

Podobne môžeme upraviť na chvostovú rekurziu aj funḱciu na výpočet Fibonacci čísel, aj keď sa v bežnej verzii volá dvakrát a nemôžu byť obe volania chvostom:

int fib(int n){
    if (n<2) return 1;
    else return fib(n-1)+fib(n-2);
}

Pôvodný rekurzívny výpočet Fibonacciho čísel je dosť pomalý, lebo jednotlivé hodnoty Fibonacciho čísel počítame totiž viackrát (čím menšie číslo, tým viackrát je spočítané).
To sa dá napraviť použitím takzvaného akumulátora, čo 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 alebo ako sme to robili bez rekurzie.
Začnete od dvoch jednotiek a postupne si dopočítate ďalšie až po číslo, ktoré ste potrebovali.
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ť.
Takto naprogramovaná Fibonacciho funkcia je rýchla a kopíruje spôsob nášho uvažovania.

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);
}

Prednáška 10

Oznamy

DÚ4 odovzdávajte do dnes
DÚ5 zverejnená dnes, odovzdávajte do pondelka 26.10. 22:00.
Pokročilú DÚ2 odovzdávajte do utorka 4.11. 22:00.

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 left a right, 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 left a right, aby sa dala spraviť rekurzia

bool contains (int a[], int left, int right, int x){
    if (left == right) return (a[left] == x);
    int index = (left + right) / 2;
    if (x <= a[index]) return contains(a, left, index, x);
    else return contains(a, index+1, right, x);
}

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í

Zostáva nám naprogramovať zlúčenie dvoch utriedených postupností. V prvej verzii predpokladajme, že máme dve utriedené postupnosti A[0..N-1] a B[0..M-1] a chceme ich zlúčiť do utriedené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 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];
}

Cvičenia 5

Cieľom tohto cvičenia je precvičiť si jednoduché príklady na rekurziu a rekurzívne triedenia.

Rekurzívne umocňovanie

Napíšte rekurzívnu funkciu int power(int x, int k), ktorá spočíta mocninu 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ť x⁰?
ako dostaneme x^k, keď poznáme x^k-1?

Rýchlejšie ale bude fungovať algoritmus, ktorý pre k>0 spočíta do pomocnej premennej rekurzívne 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á vypísať 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;
    }
}

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

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

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 11

Organizačné poznámky

Tento týždeň v piatok rektorské voľno. Doplnkové cvičenia teda nebudú, ale plánujeme spraviť budúci pondelok konzultácie.
DÚ5 odovzdávajte dnes do 22:00, zajtra očakávajte ďalšiu DÚ.
PDÚ2 do stredy 4.11. 22:00.
Blížime sa k polovici semestra. Zamyslite sa nad tým, s ktorými predmetmi máte problémy a snažte sa ich riešiť. Skúste im venovať viac času, prípadne kontaktujte cvičiacich, prednášajúcich, tútora,... Cez skúškové sa resty zo semestra budú ťažko doháňať.

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;
    cout << "Zadajte k a n: ";
    cin >> k >> 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 funkciu spravne, ak by nedostala ako parameter hodnotu 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 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 reprezentovať 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é 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 oddelovac 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 prehladat vsetky perspektivne 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 prehladat vsetky perspektivne 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?

Prednáška 12

Organizačné poznámky

Tento týždeň v piatok rektorské voľno. Programovanie beží tento aj budúci týždeň ako obvykle.
V prípade záujmu o konzultácie, resp. doplnkové cviká je možný termín pondelok 13:10-14:50 v M263 (prípadne sa presunieme).
DÚ6 odovzdávajte do utorka 3.11. do 22:00, PDÚ2 odovzdávajte do stredy 4.11. 22:00.
Čítajte svoje univerzitné maily (xxx@uniba.sk), je to pre nás jediný spôsob, ako sa na vás nakontaktovať

Opakovanie: backtrack (problém batoha)

Jednoduché riešenie -- 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.

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);
    }
}

}

Dá sa zlepšiť

ak urežeme možnosti - vetvy, ktoré už nemôžu dobre skončiť
nebudeme vždy znovu počítať súčet a hmotnosť, ale budeme si ich pamätať

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

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 (obidve typu int)?

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
}

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:

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

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

Rastúce pole

V praxi často narazíme na nasledujúci problém: chceme zo vstupu načítať do poľa nejaké údaje, ale vopred nevieme, koľko ich bude a teda aké veľké pole potrebujeme vytvoriť.

Doteraz sme to riešili konštantou MaxN ohraničujúcou maximálnu povolenú veľkosť vstupu, ale to má problémy:
- Ak je vstup väčší ako MaxN, nevieme ho spracovať, aj ak by inak kapacity počítača postačovali
- Ak je vstup oveľa menší ako MaxN, zbytočne zaberáme pamäť veľkým poľom, ktorého veľká časť je nevyužitá
Pre jednoduchosť budeme uvažovať na vstupe postupnosť nezáporných čísel ukončenú -1, napr. 7 3 0 4 3 -1
- Do poľa chceme uložiť všetko okrem poslednej -1

Riešením je postupne alokovať väčšie a väčšie polia podľa potreby

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 <iostream>
using namespace std;

int *nacitajDoPola(int &n) {
    /* Cita cele nezaporne cisla 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
    int hodnota;
    cin >> hodnota;
    while (hodnota >= 0) {
        if (n == velkost) {          // ak sme naplnili pole, presunieme 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;
        }

        pole[n] = hodnota;  // v poli je miesto, ulozime novu hodnotu
        n++;
        cin >> hodnota;
    }
    return pole;
}

int main(void) {
    int n;
    int *a;
    a = nacitajDoPola(n);   // nacitame pole a a pocet n
    for (int i = 0; i < n; i++) {  // spracovavame, ako sme zvyknuti
        cout << " " << a[i];
    }
    cout << endl;
    delete[] a;                    // nakoniec zmazeme pole a
}

Cvičenia 6

Cieľom tohto cvičenia je precvičiť si rekurzívne vypisovanie všetkých možností a prehľadávanie s návratom, čo sme preberali na prednáške 11.

Podmnožiny veľkosti k

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

Postupnosti s veľkým súčtom

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. */
}

Postupnosti s daným súčtom

Na ďalšie precvičenie rekurzie si skúste naprogramovať nasledujúce problémy podobné na príklad vypisovania postupností s veľkým súčtom vyššie.

Napíšte program, ktorý dostane čísla S a k a vypíše S všetkými možnými spôsobmi ako súčet k nezáporných celočíselných sčítancov
- Napr. S = 3, k= 2 vypíše

0+3
1+2
2+1
3+0

To isté, ale povoľte iba kladné sčítance (v príklade vyššie teda vynecháme 0+3, 3+0)
Zapíšte S všetkými spôsobmi ako súčet ľubovoľného počtu kladných sčítancov.
- Napr. pre S=3 vypíše

1+1+1
1+2
2+1
3

To isté, ale vypisujte iba neklesajúce postupnosti sčítancov, t.j. pre S=3 vynecháme postupnosť 2+1

Prednáška 13

Organizačné poznámky

Dnes konzultácie o 13:10 v M263
DÚ6 do zajtra, DÚ7 zverejníme zajtra
PDÚ2 do stredy, PDÚ3 zverejnená koncom týždňa

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 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 */

Vector

Rastúce pole, opakovanie

Na konci minulej prednášky sme videli program, ktorý postupne zväčšoval pole, až kým nenačítal všetky čísla zo vstupu
Vždy keď sa pole naplnilo, alokoval pole dvojnásobnej veľkosti a presunul všetky prvky
V programe boli pomiešané príkazy na načítavanie a na prácu s poľom
Podobné rastúce pole by sa nám mohlo zísť aj na iné účely, preto si ho teraz spravíme poriadnejšie a budeme ho nazývať vector
V C++ knižniciach je štruktúra vector, ktorá podobne rastie podľa potreby
My si naprogramujeme jednoduchšiu verziu vektora

Funkcie na prácu s dátovou štruktúrou vector

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) vráti počet prvkov vo vektore
- 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 typu 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}
    cout << get(a,0) + get(a,1) << endl;  // 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 vektora

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 nezáporné čísla zo súboru až po hodnotu -1
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) {
    vector a;                           // vytvorime a inicializujeme vektor a
    init(a);
    
    int hodnota;
    cin >> hodnota;
    while (hodnota >= 0) {
        add(a, hodnota);
        cin >> hodnota;
    }

    int sucet = 0;                       // teraz pracujeme s a, napr. spocitame sucet prvkov vo vektore
    for (int i = 0; i < length(a); i++) {
        sucet += get(a, i);
    }

    cout << "pocet: " << length(a) << ", sucet: " <<  sucet << endl; // vypise pocet prvkov a ich sucet na konzolu
    destroy(a);                            // uvolnime pamat vektora a
}

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 ako a[i][j]

Tu je kód, ktorý vynuluje maticu:

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 vstupu, musíme aj pole a alokovať pomocou new a nakoniec uvoľniť pomocou delete[]:

#include <iostream>
using namespace std;

int main(void) {
    int n, m;
    cin >> 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, dealokáciu a načítanie 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(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++) {
            cin >> 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;
    cin >> n >> m;

    /* vytvor a nacitaj maticu */
    int **a = vytvorMaticu(n, m);
    nacitajMaticu(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 13

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ázdne 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.

Príklad vstupu

Pre jednoduchosť vstup uvádzame ako nuly a jednotky bez medzier (1=živá bunka). Výslednú animáciu nájdete tu.

20 20
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000111111111100000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000
00000000000000000000

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;
    cin >> n >> m;

    /* vytvor a nacitaj maticu */
    bool **a = vytvorMaticu(n, m);
    nacitajMaticu(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);
        }
    }
}

Zdrojový kód celého programu

Tento program načíta vstup a simuluje 10 krokov hry Life: #Program Life pre prednášku 13

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. vstup 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
Vstup je ukončený prázdnym riadkom
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 <iostream>
#include <cstring>
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) {
        /* nacitame jeden riadok */
        cin.getline(riadok, maxRiadok);
        /* ak je prazdny, koncime nacitavanie */
        if (strcmp(riadok, "") == 0) {
            break;
        }
        a[n] = new char[strlen(riadok)+1];
        strcpy(a[n], riadok);
        n++;
    }

    for(int i=n-1; i>=0; i--) {
      cout << a[i] << endl;
    }
}

Ako by sme do programu pridali správne uvoľnenie pamäte?

Program mapa pre prednášku 13

/* Program Mapa z prednášky 13.
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_13 */

#include "../SVGdraw.h"
#include <iostream>
using namespace std;

/* 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(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++) {
            cin >> 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;
    cin >> n >> m;

    /* vytvor a nacitaj maticu */
    int **a = vytvorMaticu(n, m);

    nacitajMaticu(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 13

/* Program Hra Life z prednášky 13.
   http://compbio.fmph.uniba.sk/vyuka/prog/index.php/Predn%C3%A1%C5%A1ka_13 */

#include "../SVGdraw.h"
#include <iostream>
#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(int n, int m, bool **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++) {
            char c;
            cin >> c;  // nacitaj znak, preskoc biele znaky, ak nejake su
            a[i][j] = (c == '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;
    cin >> n >> m;

    /* vytvor a nacitaj maticu */
    bool **a = vytvorMaticu(n, m);
    nacitajMaticu(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();
}

Prednáška 14

Organizačné poznámky

Termín záverečnej písomky: 14.12.2015 o 14:00 ?

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

Smerníky na struct

Smerník/ukazovateľ môže ukazovať aj na struct:

struct bod {
  int x,y;
};
bod b;  b.x = 0; b.y = 0;  /* premenna typu bod */
bod *p;          /* smernik na strukturu typu bod */
p = &b;          /* p ukazuje na bod b */
bod *p2 = new bod;  /* alokovanie noveho bodu */
p2->x = 10;      /* dve formy priradovania do sucasti structu */
(*p2).y = 20;
delete p2;        /* uvoľníme alokovanú pamäť */

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

Príklad: pole smerníkov na struct

Máme štruktúru kruh, chceme od užívateľa načítať počet kruhov a potom tieto kruhy
Kruhy nedáme do poľa, tam máme len smerníky na štruktúru kruh

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

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

const double pi = 3.1415926536;

int main(void) {
    int n;
    cout << "Zadajte pocet kruhov: ";
    cin >> n;
    /* alokujeme pol n smernikov na kruh */
    kruh **kruhy = new kruh * [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 aj pole */
    for (int i = 0; i < n; i++) {
        delete kruhy[i];
    }
    delete[] kruhy;
}

Všimnite si:

kruh **kruhy = new kruh * [n]; vytvorí pole smerníkov na kruh s maxN prvkami
Prístup k polomeru i-teho kruhu: kruhy[i]->r

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;
    }

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}
Podobne pri matici a[i][j] je to isté ako *(*(a+i)+j) (ak a je typu int **)

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.
- Posunúť smerník o jeden prvok doprava môžeme pomocou 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 so smerníkovou 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 nemusí byť rovné súčtu veľkostí premenných
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

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 reťazcoch sme videli formátovanie výsledku (zarovnanie doľava) pomocou vlastnej funkcie, ktorá číslo pripravila do pomocného poľa znakov.

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čítavanie 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čítava, 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 keď hneď na začiatku končí vstup).

Postupné sčítavanie čí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 funkcie gets a tento reťazec 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

Cvičenia 7

Cieľom tohto cvičenia je precvičiť si vektor, matice, smerníky a hľadanie chýb súvisiacich s prácou s pamäťou.

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. 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 štruktúr 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 (viď prednáška 12), 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;
}

Trojuholníková matica

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 n} = 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.

Mapa

Do programu s výškovou mapou z prednášky 13 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ť.

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

Vektor

Do programu na prácu s vektorom z prednášky 13 doprogramujte funkciu void removeLast(vector &a), ktorá z poľa vyhodí posledný prvok (zmenší sa teda n) a ak bude n menšie 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 prednáške 13 bol program na simulovanie hry Life.

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 čierna, 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 odznova.

Prednáška 15

Organizačné poznámky

Tento týždeň programovanie podľa bežného rozvrhu, budúci týždeň iba cvičenia (pondelok dekanské voľno, utorok sviatok)
- Na cvičeniach budúci týždeň môže byť praktická rozcvička
DÚ7 odovzdávajte do dnes 22:00, DÚ8 bude zverejnená zajtra, termín až 23.11.
PDÚ3 je zverejnená
Termín záverečnej písomky: pondelok 14.12. o 14:00
Program valgrind môžete používať aj na klastri davinci.fmph.uniba.sk, prihlasovanie ako do AIS. Vzdialený prístup cez ssh, pre Windows napr. program putty, kopírovanie súborov cez Winscp

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á)
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í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 sa podarilo 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
}

Ešte k práci so súbormi

Štandardný vstup a výstup ako súbor

C pracuje s klávesnicou a obrazovkou ako so súborom.
V cstdio 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, napr. fscanf(stdin,"%d",&x)

Tým pádom ten istý kód sa dá použiť na prácu so súbormi aj s klávesnicou a obrazovkou - stačí len vhodne nastaviť premennú typu FILE *
Nasledujúci úryvok kódu načíta z už otvoreného súboru fr meno výstupného súboru a ak toto meno je -, pošle výstup namiesto súboru na obrazovku
Stačí pred otvorením výstupu overiť túto alternatívu a ďalej pracovať rovnako.

    FILE *fr, *fw;
    ...
    fscanf(fr, "%s", str);
    if (strcmp(str,"-") == 0) fw = stdout;
    else fw = fopen(str, "w");
    fprintf(fw, "Hello world!\n");
    ...

Testovanie konca súboru

Pomocou symbolickej konštanty EOF
- definovaná v cstdio, väčšinou má hodnotu -1
- ak sa funkcii fscanf nepodarí načítať žiadnu hodnotu kvôli koncu súboru, vráti EOF
Pomocou funkcie feof(subor)
- ak sa fscanf alebo iná funkcia pokúšala čítať za koncom súboru, feof bude pravdivé

Spracovávanie vstupu

Často očakávame na vstupe postupnosť číselných hodnôt oddelených bielymi znakmi, ktorú chceme načítavať pomocou fscanf

Pozrieme sa na tri obvyklé možnosti, ako môže byť zadaná dĺžka tejto postupnosti

Formát 1: N (počet čísel) a za tým N čísel

#include <cstdio>
#include <cassert>
int main(void) {
    FILE *f;
    const int MAXN = 100;
    int a[MAXN], N, kod;

    f = fopen("vstup.txt", "r");
    assert(f != NULL);

    kod = fscanf(f, "%d ", &N);
    assert(kod == 1 && N >= 0 && N < MAXN);

    for (int i = 0; i < N; i++) {
        kod = fscanf(f, "%d ", &a[i]);
        assert(kod == 1);
    }
    fclose(f);

    // tu pride spracovanie dat v poli a
}

Formát 2: postupnosť čísel ukončená -1 alebo inou špeciálnou hodnotu

namiesto poľa konštantnej veľkosti by sme mohli použiť vector

    // otvorime subor f ako vyssie
    N = 0;
    int x;
    kod = fscanf(f, "%d ", &x);
    assert(kod == 1);
    while (x != -1) {
        assert(N < MAXN);
        a[N] = x;
        N++;
        kod = fscanf(f, "%d ", &x);
        assert(kod == 1);
    }
    // zatvorime subor a spracujeme data

Formát 3: čísla až kým neskončí súbor

najtypickejší prípad v praxi
trochu podobný na predchádzajúci, mohli by sme napr. načítavať, kým je výsledok scanf 1
- potom by sme ale nerozoznali by správny koniec od chyby
druhá možnosť je testovať koniec pomocou feof
- priamočiary spôsob nefunguje vždy správne:

    // otvorime subor f ako vyssie
    N = 0;
    while (!feof(f)) {
        assert(N < MAXN);
        kod = fscanf(f, "%d", &a[N]);
        assert(kod == 1);
        N++;
    }
    // zatvorime subor a spracujeme data

po poslednom čísle ide v súbore často ešte koniec riadku
- program vyššie načíta posledné číslo ale v súbore zostane neprečítaný koniec riadku
- feof teda ešte nie je pravdivé
- ďalšie volanie fscanf ale vráti EOF, lebo už nenačítalo číslo
tento problém napravíme tým, že vo fscanf dáme za %d medzeru
- tá sa pokúša preskočiť všetky biele znaky až po najbližší nebiely
- pritom natrafí na koniec súboru a nastaví feof

#include <cstdio>
#include <cassert>
int main(void) {
    FILE *f;
    const int MAXN = 100;
    int a[MAXN], N, kod;

    f = fopen("vstup.txt", "r");
    assert(f != NULL);

    N = 0;
    while (!feof(f)) {
        assert(N < MAXN);
        kod = fscanf(f, "%d ", &a[N]);
        assert(kod == 1);
        N++;
    }
    fclose(f);

    // tu pride spracovanie dat v poli a
}

Ešte jeden príklad so súbormi

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,2,...,9 a súbor b.txt obsahuje čísla 10,20,...,90.

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.
Pomocou assert kontrolujeme existenciu súborov aj čísel v nich.
Pri načítaní reťazcov obmedzíme dĺžku načítaného slova podľa dĺžky poľa

#include <cstdio>
#include <cassert>
int main(void) {
    FILE *fr1, *fr2, *fw;
    char str[20];
    int kolko, hodnota, kod;

    fr1 = fopen("vstup.txt", "r");
    assert(fr1 != NULL);  // kontrola otvorenia suboru fr1
    kod = fscanf(fr1, "%19s", str);
    assert(kod==1);      // kontrola nacitaneho mena suboru
    fw = fopen(str, "w");
    assert(fw != NULL);
    while (!feof(fr1)) {  // kym neprecitame cely fr1
      kod = fscanf(fr1, "%19s %d ", str, &kolko);
      assert(kod==2);
      fr2 = fopen(str, "r");
      assert(fr2 != NULL);
      for (int i = 0; i < kolko; i++) {
        kod = fscanf(fr2, "%d ", &hodnota);
        assert(kod==1);
        fprintf(fw, "%d ", hodnota);
      }
      fclose(fr2);
    }
    fclose(fr1);
    fclose(fw);
}

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ž keď 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 znakov (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 2

Č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);
    }
}

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, pričom vo fopen použijeme argument "wb" namiesto "w" (b znamená binárny)
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).

#include <cstdio>
#include <cmath>
int main(void) {
    double a[100];
    FILE *f;

    for (int i = 0; i < 100; i++) a[i] = sqrt(i);

    f = fopen("binarny.dat", "wb");
    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].

#include <cstdio>
int main() {
    FILE *f;
    double b[5];

    f = fopen("binarny.dat", "rb");
    fread(b, sizeof(double), 5, f);
    printf("%f\n", b[4]);
    fclose(f);
}

Prednáška 16

Organizačné poznámky

Záverečná písomka 14.12.2015 od 14:00 v F2
Odovzdávanie domácich úloh: DU8 do 23.11., PDU3 do 25.11.
Organizácia najbližšieho týždňa, nebudú prednášky (16.11 a 17.11) ale cvičenia budú
Ďalší týždeň (23.-27.11.) všetko normálne

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.

Cvičenia 8

Cieľom týchto cvičení je precvičiť si prácu so súbormi a s načítavaním vstupu a výstupu.

Načítanie jednoduchých výrazov

Napíšte program, ktorý otvorí súbor vyrazy.txt, v ktorom sú na každom riadku tri údaje oddelené medzerami: desatinné číslo, znamienko (jedno z +, -, *, /) a druhé desatinné číslo. Postupne načítavajte tento súbor príkazom fscanf 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 (uložte do súboru vyrazy.txt v adresári s projektom):

1.5 + 3
-7 - -8.1
3 / 2

Výstup (konzola):

1.5 + 3 = 4.5
-7 - -8.1 = 1.1
3 / 2 = 1.5

Urezanie riadkov

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

Porovnanie súborov

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.
- Pozor na prípad, keď súbory nie sú rovnako dlhé

Štatistika

Stiahnite si textový súbor [1], 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 mesiac[4];
  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.

Formátovanie

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

Cvičenia 9

Cieľom dnešného cvičenia je precvičiť si prácu so spájanými zoznamami. Do kostry programu nižšie doprogramujte požadované funkcie na prácu s jednosmernými spájanými zoznamami. V kostre už je naprogramované načítanie dvoch zoznamov, zavolanie týchto funkcií, výpis výsledkov a uvoľnenie pamäte. Pri hľadaní chýb vo vašom programe môžete skúsiť použiť aj nástroj valgrind. Môžete použiť aj ďalšie funkcie na prácu so zoznamom z prednášky 16.

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

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á vytvorí 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 zip2, ktorá podobne vytvorí zips dvoch zoznamov, ale prvky iba preusporiada (nebude ich kopírovať a vytvárať nové node-y). Node-y teda treba iba presunúť zo z1 a z2 do z3 a vhodne zmeniť pointre.

Napíšte funkciu reverse(linkedList &z), ktorá otočí poradie prvkov v zozname (jednosmernom spájanom).

Kostra programu pre precvičenie spájaných zoznamov

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

/* štruktúra pre uzol jednosmerného zoznamu */
struct node {
    int data;  // data v uzle
    node* next;  // dalsi uzol v zozname
};

/* štruktúra pre jednosmerný spájaný zoznam */
struct linkedList {
    node* first;  // smerník na prvý prvok
};

/* inicializacia prazdneho zoznamu */
void init(linkedList &z) {
    z.first = NULL;
}

/* vypis zoznamu */
void print(const linkedList &z) {
    node* x = z.first;
    while (x != NULL) {
        cout << " " <<  x->data;
        x = x->next;
    }
    cout << endl;
}

/* nacitanie zoznamu zo vstupu */
void read(linkedList &z) {
    assert(z.first == NULL);
    int x;
    cin >> x;
    node **v = &(z.first);  // v je smernik na posledny smenrik v zozname
    while (x != -1) { // kym uzivatel nezada -1
        (*v) = new node;
        (*v)->data = x;
        (*v)->next = NULL;
        v = &((*v)->next);
        cin >> x;
    }
}

/* uvolnenie pamati pre zoznam */
void destroy(linkedList &z) {
    while (z.first != NULL) {
        node* p = z.first;
        z.first = z.first->next;
        delete p;
    }
}

/* funkcia zo zoznamu vyhodí všetky záznamy, v ktorých je data==0 */
void vyhod(linkedList &z) {
    // TODO: VAS KOD TU
}

/* funkcia vytvorí kópiu zoznamu odkial a uloží ju do zoznamu kam
 * (zoznam kam je na začiatku prázdny) */
void kopiruj(linkedList &kam, linkedList &odkial) {
    // TODO: VAS KOD TU
}

/* funkcia vytvorí z dvoch zoznamov ich "zips":
 * vo výslednom zozname sa striedajú prvky z prvého a druhého zoznamu.
 * Ak je jeden zoznam dlhší, jeho zvyšné prvky budú na konci zoznamu. */
void zip(linkedList &z1, linkedList &z2, linkedList &z3) {
    // TODO: VAS KOD TU
}

/* funkcia otočí poradie prvkov v zozname */
void reverse(linkedList &z) {
    // TODO: VAS KOD TU
}

int main(void) {
    linkedList z1;
    init(z1);
    cout << "Zadaj zoznam z1 ukonceny -1: ";
    read(z1);

    linkedList z2;
    init(z2);
    cout << "Zadaj zoznam z2 ukonceny -1: ";
    read(z2);

    cout << "Vyhadzujem nuly z z1:";
    vyhod(z1);
    print(z1);

    linkedList z3;
    init(z3);
    cout << "Kopirujem z1 do z3:";
    kopiruj(z3, z1);
    print(z3);

    linkedList z4;
    init(z4);
    cout << "Zipsujem z1 a z2 do z4:";
    zip(z1, z2, z4);
    print(z4);

    cout << "Otacam z1:";
    reverse(z1);
    print(z1);

    destroy(z1);
    destroy(z2);
    destroy(z3);
    destroy(z4);
}

Prednáška 17

Organizačné poznámky

Domáce úlohy: DÚ8 do dnes 22:00, PDÚ3 do stredy 22:00.
Zajtra bude zverejnená DÚ9, koncom týždňa PDÚ4.

Ešte k alokácii pamäti

Chceme načítať n a vytvoriť pole n intov.

const int MAXN = 100;
int n;
cin >> n;

Môžeme použiť tri spôsoby:

Spôsob 1: pole konštantnej veľkosti int a[MAXN];
Spôsob 2: pole nekonštantnej veľosti int a[n]; (variable-length array)
Spôsob 3: dynamicky alokované pole: int *a = new int[n];

Rozdiely:

Spôsoby 1 a 2 vytvárajú pole na zásobníku volaní (call stack)
- veľkosť tohto zásobníka môže byť limitovaná (v závislosti od operačného systému), preto je lepšie väčšie polia alokovať
- ak sú tieto polia lokálne premenné, zmiznú po skončení funkcie
Spôsob 2 nefunguje vo všetkých kompilátoroch
Spôsob 1 vyžaduje rozumný horný odhad na n
Spôsob 3 je mierne prácnejší (netreba zabudnúť odalokovať!), ale
- obzvlášť sa hodí na väčšie polia
- môžeme tiež vytvoriť pole vo funkcii a vrátiť ho pomocou return

Dvojrozmerné polia

My sme videli pole smerníkov na riadky matice, pričom riadky sú 1D polia dynamicky alokované
- int **a = new int * [n]; for(int i=0; i<n; i++) a[i] = new int[m];
Dá sa vytvoriť aj 2D matica, napr. int a[n][m]
- dá sa to chápať ako pole dĺžky n, ktorého prvky sú polia intov dĺžky m
- v pamäti to bude jeden kus s n krát m intami
- adresácia a[i][j] funguje nasledovne:
  - a[i] je adresa začiatku i-teho pola intov dĺžky m a [j] z tohto poľa vyberie j-ty prvok
  - na spočítanie hodnoty a[i] potrebuje program vedieť m
  - takéto pole sa v C++ nedá ľahko poslať ako parameter do funkcie ak m nie je konštanta
- z tohto dôvodu a tiež kvôli šetreniu pamäti na zásobníku je lepšie alokovať matice pomocou poľa smerníkov, ako na prednáškach

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);

/* zistí, či je rad prázdny */
bool isEmpty(queue &q);

/* pridá 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);

/* vráti prvok zo začiatku radu, ale nechá 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);

/* zistí, či je zásobník prázdny */
bool isEmpty(stack &s);

/* pridá prvok item na vrch zásobníka */
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í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 (pivot), prvky menšie ako pivot 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);

    // rekurzivne 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 niekoľko 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 detegovaná 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.

Prednáška 18

Organizačné poznámky

Tento piatok Beánia
Odovzdávanie PDÚ3 do stredy 25.11. 22:00, DÚ9 do pondelka 30.11. 22:00.

Cieľom dnešnej prednášky je precvičiť si prácu s maticami a rekurziu.

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 zásobníka 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);
        /* 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);
            }
        }
    }
}

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;
}

Výsledný program je tu: #Program Sudoku, prvá verzia

Pokus o zrýchlenie

Čo robí nasledujúca funkcia?

int kolkoMoze(int **a, int r, int s) {
    int pocet = 0;
    for (int x = 1; x <= 9; x++) {
        if (moze(a, r, s, x)) {
            pocet++;
        }
    }
    return pocet;
}

Použijeme ju teraz pri hľadaní voľného políčka:

void najdiVolne(int **a, int &r, int &s) {
    /* najdi volne policko na ploche */
    int min = 10;
    r = s = -1;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (a[i][j] == 0) {
                int pocet = kolkoMoze(a, i, j);
                if (pocet < min) {
                    min = pocet;
                    r = i;
                    s = j;
                }
            }
        }
    }
}

Ako sa takto modifikované prehľadávanie bude správať, ak na niektoré políčko plochy nie je možné dosadiť žiadnu z cifier?

Výsledný program je tu: #Program Sudoku, druhá verzia

Porovnajme teda prvý pokus a druhý pokus o riešenie Sudoku.

Prvý pokus má jednoduchšiu a rýchlejšiu funkciu najdiVolne, lebo len hľadáme prvú nulu v matici. Druhý pokus prehľadá celú maticu a pre každú nulu ešte ráta, koľko cifier je možné dosadiť.
Avšak druhý pokus oveľa skôr zistí, ak v rozrobenom riešení už nemá zmysel pokračovať. Napríklad na vstupe vyššie zavolá prvý pokus funkciu generuj 37380-krát a druhý pokus iba 213-krát.

Iné dátové štruktúry

Hraciu plochu 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.

Program ešte zovšeobecníme

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 so zložitejšími dátovými štruktúrami

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?

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, prvá verzia

Najjednoduchšia verzia pre Sudoku. Vstup aj výstup je cez konzolu.

#include <cstdio>

int pocetRieseni = 0;  // globalne pocitadlo rieseni
int pocetVolani = 0;   // globalne pocitadlo volani funkcie generuj

void vypis(int **a) {
    /* vypis riesenie sudoku a zvys pocitadlo rieseni */
    pocetRieseni++;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            printf(" %d", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

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;
}

void najdiVolne(int **a, int &r, int &s) {
    /* najdi volne policko na ploche */

    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (a[i][j] == 0) {
                r = i;
                s = j;
                return;
            }
        }
    }
    r = s = -1;
    return;
}

void generuj(int **a) {
    /* rekurzivne doplnaj vsetky moznosti za volne policka na ploche a */

    pocetVolani++;  // zvys pocitadlo volani
    int r, s;       // skus najst volne policko na ploche
    najdiVolne(a, r, s);
    if (r < 0) {    // ak volne policko nie je, vypis riesenie
        vypis(a);
    } else {        // ak mame volne policko, skus dosadit vsetky hodnoty
        for (int x = 1; x <= 9; x++) {
            if (moze(a, r, s, x)) {
                a[r][s] = x;     
                generuj(a);    // po dosadeni volaj rekurziu
                a[r][s] = 0;   // po navrate z rekurzie uprac
            }
        }
    }
}

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];
    }

    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            scanf("%d ", &a[i][j]);
        }
    }

    /* rekurzivne prehladavanie s navratom */
    generuj(a);

    /* vypis riesenia */
    printf("Pocet rieseni %d, pocet volani %d\n", pocetRieseni, pocetVolani);

    /* este by sme mali odalokovat polia v sudoku */
    for (int i = 0; i < 9; i++) {
        delete[] a[i];
    }
    delete[] a;
}

Program Sudoku, druhá verzia

Verzia, v ktorej vyberáme najviac obmedzené voľné políčko.

#include <cstdio>

int pocetRieseni = 0;  // globalne pocitadlo rieseni
int pocetVolani = 0;   // globalne pocitadlo volani funkcie generuj

void vypis(int **a) {
    /* vypis riesenie sudoku a zvys pocitadlo rieseni */
    pocetRieseni++;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            printf(" %d", a[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}

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;
}

int kolkoMoze(int **a, int r, int s) {
    /* kolko moznych hodnot x mozeme ulozit na policko a[r][s] ? */
    int pocet = 0;
    for (int x = 1; x <= 9; x++) {
        if (moze(a, r, s, x)) {
            pocet++;
        }
    }
    return pocet;
}

void najdiVolne(int **a, int &r, int &s) {
    /* najdi volne policko na ploche. Vyberame take, ktore 
     * ma najmenej moznych hodnot, ktore sa na neho daju polozit. */
    int min = 10;
    r = s = -1;
    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            if (a[i][j] == 0) {
                int pocet = kolkoMoze(a, i, j);
                if (pocet < min) {
                    min = pocet;
                    r = i;
                    s = j;
                }
            }
        }
    }
    return;
}

void generuj(int **a) {
    /* rekurzivne doplnaj vsetky moznosti za volne policka na ploche a */

    pocetVolani++;  // zvys pocitadlo volani
    int r, s;       // skus najst volne policko na ploche
    najdiVolne(a, r, s);
    if (r < 0) {    // ak volne policko nie je, vypis riesenie
        vypis(a);
    } else {        // ak mame volne policko, skus dosadit vsetky hodnoty
        for (int x = 1; x <= 9; x++) {
            if (moze(a, r, s, x)) {
                a[r][s] = x;     
                generuj(a);    // po dosadeni volaj rekurziu
                a[r][s] = 0;   // po navrate z rekurzie uprac
            }
        }
    }
}

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];
    }

    for (int i = 0; i < 9; i++) {
        for (int j = 0; j < 9; j++) {
            scanf("%d ", &a[i][j]);
        }
    }

    /* rekurzivne prehladavanie s navratom */
    generuj(a);

    /* vypis riesenia */
    printf("Pocet rieseni %d, pocet volani %d\n", pocetRieseni, pocetVolani);

    /* este by sme mali odalokovat polia v sudoku */
    for (int i = 0; i < 9; i++) {
        delete[] a[i];
    }
    delete[] a;
}

Program Sudoku so zložitejšími dátovými štruktúrami

V tejto verzii Sudoku máme uloženú hraciu plochu v zložitejších dátových štruktúrach.

#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);
    
}

Cvičenia 10

Cieľom tohto cvičenia je precvičiť si zásobník, rad a vyfarbovanie súvislých oblastí v matici.

Zásobník a rad

Tento príklad si skúste spraviť na papieri, nemusíte to programovať.
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');

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.

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.

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 19

Organizačné poznámky

DÚ9 (predposlednú) odovzdávajte do dnes 22:00.
PDÚ4 (poslednú) odovzdávajte do stredy 16.12. do 22:00

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 videli 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 prefixová 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 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, pričom * 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.
Odsimulujme na výraze 8 + 3 * 4 * 2 - 5 + 2 * 3

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 detegovať 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 a posledný 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/uzly (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

Prednáška 20

Organizačné poznámky

Domáce úlohy

Dnes zverejnená DÚ10 (posledná)
PDÚ4 do stredy 16.12.

Prednášky:

dnes viac o stromoch, dokončíme aritmetické výrazy
budúci pondelok binárne vyhľadávacie stromy
budúci utorok opakovanie, príprava na písomku a skúšku, lexikografické stromy
posledný pondelok slovník, hešovanie (môže byť na skúške)
posledný utorok nepreberané črty jazykov C a C++ (nepovinná)
- v prípade záujmu môžeme pondelok a utorok prehodiť

Pondelok 14.12. o 14:00 v posluchárni F2 písomka

Na stránke tento týždeň zverejníme ukážkové príklady na písomku
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
Opravná písomka pravdepodobne pondelok 11.1. o 14:00

Skúšky

piatok 8.1. riadny termín
piatok 15.1. riadny termín
neskôr v skúškovom ešte prvý a druhý opravný termín
strážte si konflikty s inými predmetmi

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.
- Ako funkcia očísluje vrcholy pre strom hĺbky 2?

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.

Cvičenia 11

Cieľom dnešného cvičenia je precvičiť si prácu s aritmetickými výrazmi a binárnymi stromami.

Stromy pre aritmetické výrazy

Nižšie nájdete program, ktorý obsahuje niektoré funkcie z prednášok na prácu s aritmetickými výrazmi uloženými ako strom
Rozšírte tento program tak, aby sa v aritmetickom výraze mohla vyskytovať aj premenná x. Tá sa spozná podľa toho, že v položke op štruktúry node 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, 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.
- Modifikujte aj funkciu infix, aby správne vypisovala výraz s premennou x

Binárne stromy

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 */
};

Ešte stromy

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.

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í

Program pre prácu so stromami pre aritmetické výrazy

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

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;
}

void infix(node *v) {
    /* funkcia na tlac vyrazu v infixovej notacii */
    if(v->op == ' ') {
        cout << ' ' << v->val;
    }
    else {
        cout << " (";
        infix(v->left);
        cout << " " << v->op;
        infix(v->right);
        cout << " )";
    }
}

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);
    }
}

int main(void) {
    node * vyraz = createOp('+', createNum(2), createNum(3));

    // vypis vyrazu
    cout << "Vyraz: ";
    infix(vyraz);
    cout << endl;

    // vyhodnotenie vyrazu
    cout << "Hodnota: " << evaluate(vyraz) << endl;
}

Prednáška 21

Organizačné poznámky

Domáce úlohy

Dnes termín DÚ10 (posledná)
PDÚ4 do stredy 16.12.

Budúci pondelok 14.12. o 14:00 v posluchárni F2 písomka

Opravná písomka pravdepodobne pondelok 11.1. o 14:00

Prednášky:

dnes binárne vyhľadávacie stromy
zajtra opakovanie, príprava na písomku a skúšku, lexikografické stromy
budúci pondelok slovník, hešovanie
budúci utorok nepreberané črty jazykov C a C++

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 (napr. čísel). Keďže ide o množinu, žiadny prvok sa neopakuje.
Zadefinujeme si množinu (set) ako abstraktný dátový typ (ADT) s nasledovnými tromi operáciami:

/* 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);

Mohli by sme pridať aj ďalšie operácie, napríklad

isEmpty, ktorá nám povie, či je množina prázdna,
remove, ktorá odstráni prvok z množiny,
destroy, ktorá uvoľní pamäť, ktorú dátová štruktúra zaberá,
print, ktorá vypíše všetky prvky množiny.

Ako dataType môžeme využiť typy premenných, kde vieme testovať rovnosť pomocou operátora ==, prípadne ich aj porovnávať pomocou < (napr. int, double, char).

Príklad použitia ADT množina

Na vstupe máme postupnosť celých čísel, na výstupe chceme vypísať iba prvý výskyt každého čísla (vynechať duplikáty)
Predstavme si, že máme k dispozícii implementáciu ADT množina
V množine si držíme doteraz načítané čísla
Ak sa práve načítané číslo v množine nachádza, nepotrebujeme ho pridávať ani vypisovať

typedef int dataType;

void removeDuplicates() {
    set s;
    init(s);
    while (!feof(stdin)) {
        dataType x;
        scanf("%d ", &x);
        if (!find(s, x)) { 
           insert(s, x);
           printf("%d\n", x);
        }
    }
}

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;
};

Pri inicializácii potrebujeme alokovať 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;
}

Pre vyhľadanie prvku 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 */
bool find(set s, dataType item){
    for (int i=0; i<s.count; i++){
        if (s.a[i]==item) return true;
    }
    return false;
}

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.
- Namiesto pevnej veľkosti poľa by sme mohli použiť rastúci vektor
- Nasledujúca funkcia predpokladá, že item ešte v množine nie je. Ako by sme to skontrolovali a čo by mohla funkcia robiť, ak item už v množine je?

/* prida prvok item do množiny */
void insert(set &s, dataType item){
    s.a[s.count] = item;
    s.count++;
}

Implementácia ADT množina pomocou utriedeného poľa

Pri tejto implementácii použijeme tú istú definíciu typu set a tú istú funkciu init

Funkcia insert zabezpečí, že prvky v poli a sú usporiadané od najmenšieho po najväčší
Funkcia find môže použiť binárneho vyhľadávanie v usporiadanom poli, čo je oveľa rýchlejšie (viď prednáška 7)

/* 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 */
bool find(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.
Správne miesto by sme mohli hľadať binárnym vyhľadávaním, ale my jednoducho budeme naraz od konca posúvať a porovnávať, ako pri triedení vkladaním

/* prida prvok item do množiny */
void insert(set &s, dataType item){
    int index = s.count;
    while (index > 0 && s.a[index - 1] > prvok) {
        s.a[index] = s.a[index - 1];
        index--;
    }
    s.a[index] = item;
    s.count++;
}

Cvičenie:

ako by sme v tejto funkcii overili, či sa prvok item už v poli nachádza?

Implementácia ADT množina pomocou spájaného zoznamu

ADT množina môžeme implementovať aj pomocou spájaného zoznamu.

V spájanom zozname binárne vyhľadávanie nefunguje a preto nemá zmysel udržiavať ho 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.

Časová zložitosť jednotlivých operácií

	Find	Insert
Usporiadané pole	O(log n)	O(n)
Neusporiadané pole	O(n)	O(1)
Neusporiadaný spájaný zoznam	O(n)	O(1)

Ak veľa vkladáme a málo hľadáme, je dobré použiť zoznam alebo neutriedené pole.
Ak veľa hľadáme a málo vkladáme, je dobré použiť utriedené pole.
Ak však potrebujeme približne n vkladaní aj hľadaní, všetky tri implementácie pobežia v čase 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)}
Dalo by sa to nejako zlepšiť?
- ukážeme si binárne vyhľadávacie stromy, ktoré vedia pomerne rýchlo vkladať aj hľadať v množine prvkov (prípadne aj mazať prvky z množiny)

Binárne vyhľadávacie stromy

Binárny strom, každý vrchol 0,1 alebo 2 deti
V každom vrchole máme položku s dátami (typu dataType)
Pre každý vrchol v stromu platí:
- Každý vrchol v ľavom podstrome v má hodnotu data menšiu ako vrchol v
- Každý vrchol 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;
}

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 item) {
    /* V binarnom vyhladavacom strome s korenom root najdi a vrat
     * vrchol s hodnotou item a ak neexistuje, vrat NULL. */
    node * v = root;
    while (v != NULL && v->data != item) {
        if (item < v->data) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
    return v;
}

/* rekurzivna verzia */
node * findNodeR(node *root, dataType item) {
    /* V binarnom vyhladavacom strome s korenom root najdi a vrat
     * vrchol s hodnotou item a ak neexistuje, vrat NULL. */
    if (root == NULL || root->data == item) {  
        return root;
    } else if (item < root->data) {
        return findNodeR(root->left, item);
    } else {
        return findNodeR(root->right, item);
    }
}

Čas výpočtu je v najhoršom prípade úmerný výške stromu

Pre užívateľa rekurziu obalíme do pomocnej funkcie, ktorá vráti true ak sa daná hodnota v strome vyskytuje a false inak

bool find(binarySearchTree &t, dataType item) {
  return findNode(t.root, item) != NULL;
}

Vkladanie prvku do vyhľadávacieho stromu

Predpokladáme, že prvok v strome nie je.
Putujeme po strome podobne ako pri 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 item, node * parent) {
    /* vytvor novy vrchol s danym kľúčom, obe deti nastav na NULL */
    node *v = new node;
    v->data = item;
    v->left = NULL;
    v->right = NULL;
    v->parent = parent;
    return v;
}

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

void insert(binarySearchTree &t, dataType item) {
    /* Do stromu t vlozi vrchol s hodnotou item na spravne miesto.
     * Predpokladame, ze takyto kluc este v strome nie je. */
    if (t.root == NULL) {
        /* prazdny strom - treba vytvorit koren */
        t.root = createLeaf(item, NULL);
    } else {
        node *v;
        node *parent;
        findNode(t.root, item, 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 (item < parent->data) {
            assert(parent->left == NULL);
            parent->left = createLeaf(item, parent);
        } else {
            assert(parent->right == NULL);
            parent->right = createLeaf(item, 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 v má 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;
}

Čo presne bude funkcia robiť, keď prvok v nemá nasledovníka?

Mazanie prvkov z vyhľadávacieho stromu

Nájdeme mazaný vrchol v podľa hodnoty 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 item) {
    /* Zmaze hodnotu item zo stromu t.
     * Predpokladame, ze tam taky kluc je. */

    /* Najdi vrchol s klucom */
    node *v = findNode(t.root, item);
    assert(v != NULL && v->data == item);
    /* 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

#Zdrojový kód programu s binárnymi vyhľadávacími stromami

Zhrnutie

Binárny vyhľadá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)
- Ak sme prvky vkladali v náhodnom poradí

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žitosť 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čenie

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.

Zdrojový kód programu s binárnymi vyhľadávacími stromami

/* Ukazkovy program pre pracu s binarnymi vyhladavacimi stromami */

#include <cstdio>
#include <cassert>

typedef int dataType;

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;
}


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

/* rekurzivna verzia */
node * findNodeR(node *root, dataType item) {
    /* V binarnom vyhladavacom strome s korenom root najdi a vrat
     * vrchol s hodnotou item a ak neexistuje, vrat NULL. */
    if (root == NULL || root->data == item) {  
        return root;
    } else if (item < root->data) {
        return findNodeR(root->left, item);
    } else {
        return findNodeR(root->right, item);
    }
}

/* funkcia, ktora zisti, ci sa v strome t nachadza vrchol
 * s hodnotou item */
bool find(binarySearchTree &t, dataType item) {
  return findNodeR(t.root, item) != NULL;
}

node * createLeaf(dataType item, node * parent) {
    /* vytvor novy vrchol s danym kľúčom, obe deti nastav na NULL */
    node *v = new node;
    v->data = item;
    v->left = NULL;
    v->right = NULL;
    v->parent = parent;
    return v;
}

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

void insert(binarySearchTree &t, dataType item) {
    /* Do stromu t vlozi vrchol s hodnotou item na spravne miesto.
     * Predpokladame, ze takyto kluc este v strome nie je. */
    if (t.root == NULL) {
        /* prazdny strom - treba vytvorit koren */
        t.root = createLeaf(item, NULL);
    } else {
        node *v;
        node *parent;
        findNode(t.root, item, 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 (item < parent->data) {
            assert(parent->left == NULL);
            parent->left = createLeaf(item, parent);
        } else {
            assert(parent->right == NULL);
            parent->right = createLeaf(item, parent);
        }
    }
}

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;
}

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;
}

void remove(binarySearchTree &t, dataType item) {
    /* Zmaze hodnotu item zo stromu t.
     * Predpokladame, ze tam taky kluc je. */

    /* Najdi vrchol s klucom */
    node *v = findNode(t.root, item);
    assert(v != NULL && v->data == item);
    /* 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;
}

void inorder(node *v) {
    if (v == NULL) return;
    inorder(v->left);
    printf(" %d",  v->data);
    inorder(v->right);
}

int main() {
    /* vytvorime a inicializujeme strom */
    binarySearchTree t;
    init(t);
    /* vlozime zopar klucov */
    insert(t, 2);
    insert(t, 5);
    insert(t, 3);
    insert(t, 10);
    insert(t, 7);    
    /* skusime hladat */
    if(find(t,4)) printf("Nasiel 4\n");
    if(find(t,3)) printf("Nasiel 3\n");
    /* vypiseme vsetky kluce v inorder poradi
     * mali by byt usporiadane podla velkosti */
    inorder(t.root);
    printf("\n");
    /* pomazeme kluce */
    remove(t, 5);
    remove(t, 3);
    remove(t, 10);
    remove(t, 7);
    remove(t, 2);
}

Prednáška 22

Organizačné poznámky

Dobeh semestra:

PDÚ4 odovzdávanie do 16.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, začiatok lexikografických stromov
- budúci pondelok pokračovanie lexikografických stromov, slovník, hešovanie
- budúci utorok 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Ú 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

BUDE: 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
- BUDE: lexikografický strom (ak kľúč je reťazec)
- BUDE: hešovacia 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

Lexikografické stromy (trie)

Vhodná štruktúra na ukladanie množiny v ktorej prvky 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

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

Do uzla pridáme počítadlo výskytov
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ó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);
}

Cvičenia 12

Cieľom tohto cvičenia je precvičiť si prácu s lexikografickými stromami a binárnymi vyhľadávacími stromami.

Binárne vyhľadávacie stromy

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

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.
- Aby ste ste funkciu otestovali, vypíšte strom v infixovom poradí (hodnoty by mali byt vypisané utriedené). Použite napríklad časti programu z prednášky 21.

Lexikografické stromy

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.

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.

Lexikografických stromov sa týka aj druhý ukážkový príklad na skúšku, ktorý si môžete doma v rámci tréningu vyskúšať naprogramovať a odovzdať na testovači.

Naprogramujte funkciu, ktorá uprace lexikografický strom, t.j. uvoľní všetky vrcholy, ktoré vo svojom podstrome nemajú žiaden vrchol, kde isWord je pravdivé.

Prednáška 23

Organizačné poznámky

PDÚ4 odovzdávajte do stredy 16.12. 22:00
Dnes a zajtra posledné prednášky, v stredu posledné cvičenie s poslednou rozcvičkou
Nepovinné cvičenie nebude
Dnes písomka o 14:00. Body z písomky nájdete na testovači. Opravná/náhradná písomka bude v pondelok 11.1. o 14:00.

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

ADT slovník (asociatívne pole)

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 množina poskytuje operácie init, insert, find, príp. delete, atď
Videli sme aj ďalšie ADT, napr. vektor, zásobník, rad
Pre jeden ADT môže byť viacero implementácií, napr. množina 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é

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ťou 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, lexikografickým stromom) sa dajú ľahko rozšíriť na implementácie ADT slovník.

Implementáciu hešovaním si teraz ukážeme

Implementácia ADT slovník pomocou hešovania

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
}

Lexikografické stromy

Na prednáške 22 sme si ukázali lexikografické stromy. Implementácia slovníka s kľúčom, ktorý je reťazec je možná aj pomocou lexikografických stromov.

Podobne úlohu s počítaním výskytu slov môžeme vyriešiť aj pomocou lexikografických stromov.

Zdrojové kódy

Zdrojový kód 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
}

Prednáška 24

Organizačné poznámky

Body z písomky na testovači.
- Opravná/náhradná písomka bude v pondelok 11.1. o 14:00, prihláste sa v AIS
- Písomku si môžete prezrieť počas poobednajšej časti skúšky. Ak ju chcete vidieť skôr, dohodnite si termín
PDÚ4 odovzdávajte do zajtra 22:00
Zajtra posledné cvičenie s poslednou rozcvičkou, na cvičení trénovacie príklady na skúšku alebo otázky k učivu zo semestra
Ak máte záujem o nepovinné cvičenie, dajte vedieť J. Katreniakovej, inak nebude
Nezabudnite sa v AIS zapísať na termín skúšky
Tento týždeň bude spustená študentská anketa

Nepreberané črty jazykov C a C++

Na dnešnej prednáške 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 a 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.
Typ enum: vymenujeme možné hodnoty, tie sa stanú celočíselnými konštantami: enum farby {biela, cierna, cervena};
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

Príklad: vrchol stromu pre aritmetické výrazy pomocou union (zapísaný v mierne skrátenej syntaxi z C++)

Na mojom počítači pôvodná aj nová verzia zaberá 32 bajtov.
- Smerník aj double zaberajú 8 bajtov, bool aj char 1 bajt
- Teoreticky by teda mohlo stačiť 18 bajtov s union vs. 25 bajtov bez union
- Ale kompilátor umiestňuje časti structov na miesta s rýchlejším prístupom.
Ak by sme namiesto bool isValue použili rovno char op, zaberala by štruktúra iba 24 bajtov.

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

struct origNode {   /* vrchol stromu z prednasky */
    double val;     /* ciselna hodnota */
    char op;        /* operator '+', '-', '*', '/', 
                     * alebo ' ' ak ide o hodnotu */
    origNode * left;    /* lavy podvyraz alebo NULL */
    origNode * right;   /* pravy podvyraz alebo NULL */
};

struct nodeWithUnion;

struct operatorNode {
    char op;
    nodeWithUnion * left;    /* lavy podvyraz alebo NULL */
    nodeWithUnion * right;   /* pravy podvyraz alebo NULL */
};

struct nodeWithUnion {   /* vrchol stromu pomocou union */
  bool isValue;
  union {
    double val;     /* ciselna hodnota */
    operatorNode o;
  };
};

nodeWithUnion * createOp(char op, nodeWithUnion *left, nodeWithUnion *right) {
    nodeWithUnion *v = new nodeWithUnion;
    v->isValue = false;
    v->o.left = left;
    v->o.right = right;
    v->o.op = op;
    return v;
}

nodeWithUnion * createNum(double val) {
    nodeWithUnion *v = new nodeWithUnion;
    v->isValue = true;
    v->val = val;
    return v;
}

int main() 
{
  cout << "velkost vrchola z prednasky " << sizeof(origNode) <<endl;
  cout << "velkost vrchola s union " << sizeof(nodeWithUnion) << endl;

  nodeWithUnion *v = createNum(1.5);
  cout << v->val << endl;  // spravne pouzitie 
  cout << v->o.op << endl;  // zle pouzitie, nenajde kompilator ani valgrind
}

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 vráti 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 utriedenom poli

Odbočka: argumenty typu const

v príklade vyššie máme funkciu s hlavičkou int compare (const void * a, const void * b)
argument typu const void * a znamená, že programátor sľubuje, že pamäť, kam a ukazuje, nebude meniť
ak by sme mali funkciu void f(const int *a) { a = 5; }, kompilátor by vyhlásil chybu
ak by sme naopak pri triedení chceli použiť funkciu s hlavičkou int compare (void * a, void * b), kompilátor tiež vyhlási chybu, lebo qsort očakáva const void*, nie void*.
preto pri použití štandardných knižníc potrebujete občas na vhodné miesta pridať const
- dobrá prax je konzistentne dávať const na všetky parametre typu smerník alebo referencia, ktoré funkcia nepotrebuje meniť

Jazyk C++

Generické funkcie

Niekedy chceme napísať algoritmus, ktorý by mohol fungovať na 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);

O generických funkciách sa budeme viac učiť budúci semester.

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 < (const meno &x, const 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 structy reprezentujúce trebárs polynómy alebo komplexné čísla...
cout << "Hello" používa preťažený operátor << ak na ľavej strane je stream a na pravej reťazec

String

Okrem klasických C-čkových reťazcov môžeme použiť aj typ string z C++.
Má elegantnejšie používanie, sám si určuje potrebnú veľkosť pamäte
Sú to objekty, do funkcií odovzdávame väčšinou referenciou (cez &)
K 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*

Stream

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 true, ak vznikla chyba (väčšinou pri otvorení neexistujúceho súboru). Druhou možnosťou je testovať správne otvorenie pomocou testovania premennej typu ofstream alebo ifstream.
- technicky ide o preťaženie operátora konverzie na bool resp. na void*, robí negáciu funkcie 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 podobnými štruktúrami v Jave

Štruktúra vector [2]

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] - podobne ako pri poliach nekontroluje rozsah
- A.at(index) - v prípade indexu mimo rozsahu program hneď spadne (presnejšie vyhodí výnimku) - nenarobí chaos v pamäti, kde sa potom ťažko hľadá chyba
V obidvod prípadoch môžeme aj priraďovať A[index]=value; A.at(index)=value;

Vkladanie nových prvkov na koniec uloženej postupnosti
- A.push_back(x) vloží hodnotu x, podľa potreby alokuje nové polia, presúva a pod.
- A.size() vráti počet prvkov v poli
- A.resize(n) alebo A.resize(n, value) zmení počet prvkov v poli na n, pričom buď zahodí nadbytočné prvky alebo pridá nové - tie budú mať hodnotu value alebo default
- A.capacity() nám povie dĺžku alokovaného poľa a A.reserve(n) nám ju umožní zväčšiť, ale väčšinou sa o tieto implementačné detaily nestaráme

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 pomocou 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);

Range-based for loop (v štandarde C++11)

Špeciálny cyklus cez prvky vektora a pod.
- nepotrebujeme zavádzať premennú pre index
- podobný for cyklus uvidíme podrobnejšie v Jave

Štandard C++11 musíme zapnúť v kompilátore, napr. g++ -std=c++11
- Implementácia tohto štandardu ešte nemusí byť úplná

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

void vypis(const vector<int> &a) {
  // vypise vsetky prvky vektora a
  for (const int &value : a) { 
    cout << value << ' ';
  }
  cout << '\n';  
}

int main() 
{
  vector<int> a;

  // do vektora a vlozi prvky 0,..,5
  for(int value : {0,1,2,3,4,5}) {
    a.push_back(value);
  }

  vypis(a);  // vypise 0 1 2 3 4 5
 
  // zvysi kazdy prvok vektora o 1
  for (int &value : a) { 
    value++;
  }

  vypis(a); // vypise 1 2 3 4 5 6
}

Cvičenia 13

Na dnešnom cvičení odporúčame vyriešiť niektorý z tréningových príkladov na skúšku: 1a, 1b, 2a, 2b

2015/16 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

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: Hello world

Príklad 2: odovzdávanie domácich úloh

Príklad 3: vstup, výstup, podmienka if

Príklad 4: cyklus

Príklad 5: práca s grafickou knižnicou

Príklad 6: DÚ1