2019/20 Programovanie (1) v C/C++

• #Zimný semester, úvodné informácie
• #Zimný semester, pravidlá
• #Zimný semester, skúška
• #Zimný semester, softvér

Týždeň 23.-29.9. Úvod, premenné, podmienky, výrazy, cyklus for

#Prednáška 1 · #Prednáška 2 · #Cvičenia 1 · #Testovač

Týždeň 30.9-6.10. Ďalšie príklady na cykly, Euklidov algoritmus, cyklus while, funkcie

#Prednáška 3 · #Prednáška 4 · Cvičenia 2

Týždeň 7.-13.10. V pondelok teoretické cvičenia namiesto prednášky, polia, struct

#Teoretické cvičenie · #Prednáška 5 · Grafická knižnica SVGdraw · Cvičenia 3 · DÚ1

Týždeň 14.-20.10. Eratostenovo sito, jednoduché triedenia, binárne vyhľadávanie, zložitosť, znaky, switch

#Prednáška 6 · #Prednáška 7 · Cvičenia 4

Týždeň 21.-27.10. Reťazce, úvod do rekurzie

#Prednáška 8 · #Prednáška 9 · Cvičenia 5 · DÚ2

Týždeň 28.10.-3.11. Prehľadávanie s návratom, Mergesort, Quicksort

#Prednáška 10 · #Prednáška 11 · Cvičenia 6

Týždeň 4.-10.11. Smerníky, dynamické polia, práca s dvojrozmernými údajmi

#Prednáška 12 · #Prednáška 13 · Cvičenia 7

Týždeň 11.-17.11. Spájaný zoznam, hešovanie, práca s konzolou na spôsob jazyka C, úvod to textových súborov

#Prednáška 14 · #Prednáška 15 · Cvičenia 8 · DÚ3 + bonus

Týždeň 18.-24.11. Pokračovanie textových súborov, binárne súbory, zásobník, rad

#Prednáška 16 · #Prednáška 17 · Cvičenia 9

Týždeň 25.11.-1.12. Vyfarbovanie, aritmetické výrazy

#Prednáška 18 · #Prednáška 19 · Cvičenia 10 · DÚ4

Týždeň 2.-8.12. Aritmetické stromy, binárne stromy vo všeobecnosti, binárne vyhľadávacie stromy

#Prednáška 20 · #Prednáška 21 · Cvičenia 11

Týždeň 9.-15.12. Lexikografické stromy, opakovanie, informácie ku skúške

#Prednáška 22 · #Prednáška 23 · Cvičenia 12 · #Zimný semester, príklady na test

Týždeň 16.-22.12. Nepreberané črty C a C++

#Prednáška 24 · Cvičenia 13

Zimný semester, úvodné informácie

Základné údaje

Rozvrh

• Prednášky: pondelok 9:50-11:20 F1-328 a streda 9:50-11:20 F1-328
• Hlavné cvičenia: utorok 13:10 I-H6, I-H3
• Doplnkové cvičenia: piatok 13:10 I-H6

Vyučujú

• doc. Mgr. Broňa Brejová, PhD., miestnosť M-163,
• RNDr. Peter Kostolányi, PhD., miestnosť M-227,
• Mgr. Michal Anderle, miestnosť M-249,
• Andrej Korman

Konzultácie po dohode e-mailom.

Ak nemáte otázku na konkrétnu osobu, odporúčame vyučujúcich kontaktovať pomocou spoločnej adresy e-mailovej adresy . Odpovie vám ten z nás, kto má na starosti príslušnú otázku alebo kto má práve čas.

Ciele predmetu

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

Literatúra

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

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. Hlavnou náplňou cvičenia je riešenie zadaných príkladov individuálne alebo vo dvojiciach. Cvičiaci vám podľa potreby pomôže a poradí.
• Príklady z hlavných cvičení, ktoré nestihnete vyriešiť, odporúčame dokončiť doma.
• 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čiacich môžete dokončovať príklady z predchádzajúcich cvičení, pýtať sa otázky k učivu, prípadne pracovať na domácej úlohe.
• Domáce úlohy budú cca 4 cez semester. Pracujte na nich samostatne doma, prípadne na doplnkových cvičeniach. Nechajte si na ne dosť času, nezačnite tesne pred termínom.
• Príklady na cvičenia a domáce úlohy navrhujeme tak, aby vám ich riešenie pomohlo precvičiť si učivo, čím sa okrem iného pripravujete aj na záverečnú skúšku. Okrem tohto sú za tieto príklady body do záverečného hodnotenia. Najviac sa naučíte, ak sa vám príklad podarí samostatne vyriešiť, ale ak sa vám to napriek vášmu úsiliu nedarí, neváhajte sa spýtať o pomoc vyučujúcich. Možno s malou radou od nás sa Vám podarí úlohu spraviť.
• 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 odporúčame 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ť.

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 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. Odporúčame chodiť aj na doplnkové cvičenia, ďalšie príklady riešiť doma. 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ť 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 cvičení.
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 riešením ľahkých príkladov, odporúčame test pre pokročilých a pokročilé domáce úlohy. Aj tak však potrebujte absolvovať skúšku, prípadne aj niektoré písomky, takže priebežne sledujte učivo a v prípade nejasností sa pýtajte.

Zimný semester, pravidlá

Známkovanie

• 25% známky je na základe príkladov z cvičení
• 15% známky je za domáce úlohy
• 30% známky je za písomky počas semestra
• 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% z celkového súčtu písomiek
  • 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%

Príklady z cvičení

• Na hlavnom cvičení bude zverejnených niekoľko príkadov. Príklady odovzdávate do automatického testovača. Ak úspešne prejdú všetkými testami, môžete za ne dostať body (podmienkou však je dodržať aj ďalšie pokyny v zadaní úlohy).
• Jeden príklad, označený ako rozcvička, bude mať termín odovzdania počas hlavného cvičenia, neskôr teda zaňho body nedostanete.
• Ďalšie príklady môžete odovzdávať až do začiatku ďalšieho hlavného cvičenia.
• Na doplnkovom cvičení môže byť zadaná ešte jedna rozcvička za malý počet bonusových bodov.
• Príklady z cvičení môžete robiť aj vo dvojicich. Príklad potom odovzdáva jeden člen dvojice a uvedie svojho partnera. Body dostanú obaja.
  • V prípade problémov môžu vyučujúci prácu vo dvojicich regulovať.
  • Jeden príklad vždy riešte s najviac jedným spolužiakom/spolužiačkou.
  • Na riešení pracujte spolu, obaja mu musia do detailov rozumieť. Ideálne je byť v dvojici s niekým na podobnej úrovni programátorských skúseností.
• Ak v niektorom týždni nezískate žiadne body z príkladov z cvičení, dostanete za tento týždeň -5 bodov. Nakoľko každé cvičenia predstavujú materiál z dvoch prednášok, nie je rozumné celý týždeň preskočiť.
• Namiesto prednášky v pondelok 7.10. budú špeciálne cvičenia, kde budete riešiť príklady na papieri. Body za tieto príklady sa tiež rátajú do bodov z cvičení.

Domáce úlohy

• Domáce úlohy sa budú tiež odovzdávať na testovači, budú však opravované ručne.
• Plný počet bodov môžu dosť iba programy, ktoré prejdú všetkými testami, čiastočné body však môžete dosť aj za nedokončený program.
• Budeme kontrolovať správnosť celkovej myšlienky, správnosť implementácie ale body môžete stratiť aj za neprehľadný štýl.
• Domáce úlohy robte samostatne, nie v dvojiciach.

Písomné testy

• Počas semestra budú 3 písomné testy (na papieri) v rozsahu 60 minút.
• 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.
• Termíny testov, všetky v posluchárni A:
  • 1. test streda 16.10. 18:10 (opravná v týždni od 4.11.)
  • 2. test streda 20.11. 18:10 (opravná cez skúškové)
  • 3. test streda 11.12. 18:10 (opravná cez skúškové)

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.

Neprítomnosť a opravné termíny

• Domáce úlohy a príklady z cvičení je potrebné odovzdať do určeného termínu. Neskoršie odovzdané riešenia nebudú braté do úvahy ak nezískate výnimočné predĺženie termínu od vyučujúcich.
• Účasť na hlavných cvičeniach veľmi silne odporúčame a v prípade neprítomnosti stratíte body z rozcvičky. Väčšiu časť bodov môžete získať aj riešením príkladov doma.
• Ak zo závažných dôvodov (napr. zdravotných) nemôžete prísť na písomku, skúšku resp. načas odovzdať domácu úlohu či príklady z cvičení, kontaktujte vyučujúcich emailom. Treba tak spraviť čím skôr, nie až spätne cez skúškové. Môžeme požadovať potvrdenku od lekára.
• Každý písomný test má jeden opravný termín.
  • 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.
  • Opravné termíny testov môžu byť aj cez skúškové.
• 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.

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é ukazovať svoj kód spolužiakom. Domáce úlohy môžu byť kontrolované softvérom na detekciu plagiarizmu.
• Podobne pri riešení príkladov z cvičení pracujte buď samostatne alebo v dvojici.
• Tiež je zakázané opisovať kód z literatúry alebo z internetu (s výnimkou webstránky predmetu). Pri práci môžete používať webstránky s popisom programovacieho jazyka, nesnažte sa však nájsť priamo riešenie zadaného príkladu.
• Počas 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 0 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.
• Za závažné porušenie pravidiel budeme považovať aj akýkoľvek pokus narušiť činnosť testovača riešení.

Osobné stretnutia

• Vyučujúci vás môžu vyzvať emailom, aby ste prišli na stretnutie ohľadom príkladov, ktoré ste riešili a odovzdali mimo času cvičení (domáce úlohy, príklady z cvičení)
• Na tomto stretnutí im vysvetlíte, ako ste príklad riešili
• Ak ste príklad riešili vo dvojici, osobné stretnutie má každý zvlášť, každý by mal rozumieť celému riešeniu
• Stretnutia sa budú konať počas doplnkových cvičení alebo po dohode v inom čase
• Ak na stretnutie neprídete alebo nebudete vedieť svoj program vysvetliť, stratíne zaňho body

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 riešením ľahkých príkladov počas semestra.

Test pre pokročilých

• V prvom týždni semestra sa bude konať nepovinný test pre pokročilých.
• 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 100% bodov z jedných cvičení (bez bonusov). Napr. ak ste získali 59% z testu, dostanete plný počet bodov z prvých 5 bodovaných cvičení po opravení testu. Tieto body nie je možné presúvať na iné termíny cvičení a z týchto uznaných cvičení už nemôžete získať ďalšie body.
• Navyše budete mať uznané aj niektoré semestrálne písomné testy nasledovne:
  • 50-75% z testu: prvý test za plný počet bodov, ostatné píšete so spolužiakmi
  • 75-90% z testu: dva písomné testy za plný počet bodov (vyučujúci určia, ktoré dva), jeden test píšete so spolužiakmi
  • 90-100% z testu: zo všetkých 3 semestrálnych testov dostanete plný počet bodov

Domáce úlohy pre pokročilých

• Pokročilí programátori môžu namiesto bežných domácich úloh získať body za úlohy vyriešené na predmete Rýchlostné programovanie (1)
• Rýchlostné programovanie je určené na precvičenie programovania, algoritmov a hlavne ako príprava na programátorské súťaže. Úlohy na tomto predmete vyžadujú aj znalosti nepreberané na prednáškach z Programovania.
• Tie isté úlohy môžete použiť aj do hodnotenia Programovania aj Rýchlostného.
• Do hodnotenia Programovania (1) môžete započítať iba tie úlohy z Rýchlostného, ktoré vyriešite v jazyku C alebo C++ a počas semestra, t.j. najneskôr 20.12.
• 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.
• Ak chcete namiesto úloh použiť Rýchlostné (a máte povolenie), najneskôr 11.10. odovzdajte na našom testovači do špeciálnej úlohy Rýchlostné textový súbor, ktorý bude obsahovať vašu prezývku používanú na serveri Rýchlostného programovania.
• Potom najneskôr 20.12. odovzdajte novú verziu tohto súboru, ktorá bude obsahovať vašu prezývku a zoznam všetkých príkladov z Rýchlostného, ktoré chcete započítať ako DÚ na Programovaní. Musia to byť len príklady vyriešené jazyku C alebo C++. Pri každom príklade napíšte, koľko za neho máte bodov na Rýchlostnom (1 alebo 2 body).
• Body z Rýchlostného sa prepočítajú na body z DÚ nasledovne:
  • Rýchlostné aspoň 6 bodov: 50% bodov z DÚ, t.j. 7.5% do celkového hodnotenia predmetu
  • Rýchlostné aspoň 8 bodov: 100% bodov z DÚ, t.j. 15% do celkového hodnotenia predmetu
  • Rýchlostné aspoň 12 bodov: 110% bodov z DÚ, t.j. 16.5% do celkového hodnotenia predmetu
  • Rýchlostné aspoň 16 bodov: 120% bodov z DÚ, t.j. 18% do celkového hodnotenia predmetu
• Body z bežných DÚ a z Rýchlostného programovania nie je možné sčítať. Ak do 20.12. neodovzdáte zoznam príkladov, započítame vám body z odovzdaných domácich úloh. Ak odovzdáte neprázdny zoznam príkladov, použijeme ten.

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ť na testovači bez zvláštnych nastavení kompilátora a pod.

Zimný semester, skúška

Odporúčame tiež si preštudovať pravidlá predmetu.

Termíny, prihlasovanie

Boli zverejnené predbežné termíny skúšok

• piatok 20.12. 13:10 predtermín (koná sa len pri dostatočnom záujme, viď nižšie)
• štvrtok 9.1. 13:00 riadny termín
• štvrtok 23.1. 9:00 riadny termín alebo prvý opravný termín
• piatok 31.1. 9:00 prvý opravný alebo druhý opravný termín
• koncom skúškového ešte bude v prípade potreby druhý opravný termín

Prihlasovanie

• Na termín skúšky sa prihlasujte v AIS/Votr
• Na termín sa prihlasujte / odhlasujte najneskôr 24 hodín pred začiatkom termínu
• Prihlasujte sa čím skôr, termíny majú limitovanú kapacitu
• Na predtermín 20.12. sa treba prihlásiť aspoň týždeň dopredu, do piatku 13.12. 13:10. Ak na predtermín 20.12. nebude prihlásených aspoň 10 študentov, predtermín sa nebude konať
• Opravnú písomku môžete na tomto predmete písať aj po skúške
• Celkovo budú iba uvedené štyri termíny plus prípadný predtermín. Každý sa môže zúčastniť na najviac troch z nich, ďalšie termíny neplánujeme pridávať

Ak zistíte konflikt našej skúšky s hromadnou skúškou alebo písomkou iného predmetu, dajte nám vedieť čím skôr. Na poslednú chvíľu už nedokážeme nájsť riešenie.

Základné pokyny

• 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é.
• Stretávame sa vždy desať minút pred začiatkom skúšky pred počítačovou miestnosťou, kde sa dozviete pokyny a rozsadenie
• Skúška: 2 hodiny práca pri počítačoch
  • Za špeciálnych pravidiel môže byť čas predĺžený o 30 minút, viď pravidlá nižšie
  • Počas skúšky vám nebudeme pomáhať hľadať chyby vo vašom programe. Môžete sa však spýtať na nejasnosti v zadaní. Dajte nám tiež vedieť v prípade technických problémov alebo ak si myslíte, že v zadaní / kostre / vstupoch je chyba.

Po skúške

• Po skúške vyučujúci obodujú vaše programy. Výsledky nájdete na testovači, známky v AIS.
• Ak máte výhrady k prideleným bodom, kontaktujte vyučujúcich najneskôr do týždňa po skúške.
• Spravidla na druhý deň po skúške bude vyhradený čas, kedy môžete prísť si dať zapísať známku do indexu a tiež sa porozprávať o tom, čo ste mali v programe dobre alebo zle.
• Na takéto stretnutie odporúčame prísť aj tým, ktorí skúšku nespravili. Môžeme vám poradiť, ako postupovať na opravnom termíne.
• Ak chcete iba zapísať známku, index môžete poslať aj po spolužiakovi alebo prísť po inom termíne skúšky. Známky však zapisujeme iba v časoch na to určených, nie keď zrovna idete okolo. Známku si potrebujete dať do indexu zapísať najneskôr do konca skúškového.
• Ak niekto skúšku ukončí v dostatočnom predstihu pred koncom 2-hodinovej doby skúšky a priebeh skúšky to umožní, skúšajúci môžu jeho programy obodovať už počas skúšky a priamo aj udeliť známku a zapísať ju do indexu.

Technické detaily

• Skúška bude v Linuxe, rovnaké prostredie ako na cvičeniach
• Odovzdávanie prostredníctvom špeciálnej verzie testovača
• Okrem testovača nebude k dispozícii internet
• Budete používať špeciálne skúškové konto, takže nebudete mať k dispozícii žiadne svoje súbory alebo nastavenia
• Pri reštarte počítača sa stratia všetky súbory, používajte testovač ako zálohu (odovzdajte aj nedokončený program)
• Môžete použiť Kate, valgrind, Netbeans, ale aj iné nástroje, ktoré bežia v Linuxe v učebniach a nepotrebujú internet. Prípadné problémy s použitím iného softvéru vám však nebudeme pomáhať riešiť
• 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ť na testovači bez zvláštnych nastavení kompilátora a pod.
  • Odporúčame používať iba tie časti jazyka, s ktorými máte dostatočné skúsenosti. Príkazy, ktoré si nepamätáte, si dajte na ťahák.

Opravné termíny

• 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ámku 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ť 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.

Príklady

Na skúške budete riešiť dva príklady za rovnaký počet bodov

Prvý príklad

• 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.
• Budú však zakázané polia pevných veľkostí. Polia alokujte dynamicky cez new, alebo použite štruktúry, ktoré menia veľkosť podľa potreby (napr. string, vector). Alokovanú pamäť odalokujte.
• 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ť.

Druhý príklad

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

Hodnotenie

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, statickým poliam, menšej chybe, ktorá sa neprejavila na daných vstupoch a pod.
• Dobre si rozmyslite, s ktorým príkladom chcete začať a snažte sa ho dokončiť, kým nedostanete OK na testovači. Potom ho môžete ešte vylepšovať alebo sa snažiť vyriešiť aspoň časť príkladu, ktorý ste ešte neriešili.

Bodové hodnotenie

• V prvom rade budeme hodnotiť správnosť myšlienky vášho programu. Predtým, ako začnete programovať, si dobre prečítajte zadanie a 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.

Predĺženie času

• Ak v riadnom čase 2 hodiny nemáte na testovači OK ani z jedného príkladu, zo skúšky by ste mali dostať Fx.
• Dovolíme vám však predĺžiť čas skúšky o najviac 30 minút.
• Ak zostanete na predĺženie, budeme vám rátať do výsledku body iba z jedného príkladu. Konkrétne z toho, za ktorý ste dostali OK na testovači (ak z oboch, tak z toho, za ktorý ste mali OK skôr)

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

Niektoré ukážkové príklady na skúšku budú k dispozícii na testovači, môžete si ich v rámci tréningu vyriešiť a odovzdať. Pre realistickejší tréning si vždy prečítajte zadanie tesne predtým, ako príklad začnete riešiť, aby ste odhadli, koľko času vám príklad zaberie vrátane čítania zadania a rozmýšľania nad riešením.

Špeciálne pravidlá pre predtermín

• Na predtermín sa v AIS da prihlásiť / odhlásiť najneskôr týždeň vopred, po tomto termíne iba pri závažných okolnostiach emailom B. Brejovej.
• Ak sa zúčastňujete predtermínu, body za tréningové príklady môžete dostať iba ak ich vyriešite do 20.12. 23:55. (toto neplatí, ak po predtermíne ešte idete na opravný termín skúšky)
• Výsledky oznámime najneskôr v pondelok 23.12., ale známky do indexov budeme zapisovať až v januári po prvom riadnom termíne. Prípadné reklamácie bodov alebo známok z predtermínu nám dajte vedieť najneskôr do 7.1.
• Počas predtermínu spravidla nebudeme zapisovať známky do indexov (ani pri skoršom odovzdaní), vzhľadom na to, že nebude ukončené vyhodnotenie poslednej DÚ, DÚ pre pokročilých a tréningových príkladov.

Zimný semester, softvér

V tomto dokumente popisujeme niektoré nástroje, ktoré môžete použiť na programovanie v tomto semestri. Na cvičeniach a skúške odporúčame používať editor Kate popísaný nižšie.

Môžete používať aj iné nástroje, ale

• k iným prostrediam vám nemusíme vedieť poradiť, ako ich používať
• na skúške budete môcť používať iba tie programy, ktoré sú k dispozícii v učebniach na fakulte v Linuxe, pričom nebude k dispozícii internet

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

• Pri odovzdávaní domácich úloh odovzdávajte súbor .cpp s vašim programom (prípadne ďalšie súbory, ak to vyžaduje zadanie).
• 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
• Odovzdané programy si môžete počas semestra stiahnuť z testovača, po začiatku ďalšieho semestra k ním stratíte prístup

Kate

Kate je základný textový editor, ponúka však dostatok nastavení, aby sa s v ňom pohodlne písali jednoduché programy (nie je však úplne vhodný na väčšie projekty).

Ako spustiť Kate v učebni

• Prihláste sa do Linuxu rovnakým menom a heslom, aké používate v AISe
• V menu s ponukou programov nájdite Kate (v časti Utilities), alebo stlačte ALT+F2 a napíšte Kate
• Odporúčame sedieť vždy pri tom istom počítači, máte uložené nastavenia

Vytvorenie nového programu

• File -> New (Ctrl+N) vytvorí nový textový súbor
• Uložte ho pomocou File -> Save (Ctrl+S), bude od vás žiadať nejaké meno a môžete si zvoliť kam bude daný súbor umiestnený. Nazvať si ho môžeme napr. program.cpp
• Dôležité je pridať koncovku .cpp , vďaka nej Kate vie, že chcete programovať v C++ a mal by vám automaticky zapnúť C++ zvýrazňovanie (ktoré je veľmi praktické)

Nastavenia editora

Na programovanie odporúčame spraviť / skontrolovať nasledujúce nastavenia (keď máte otvorený .cpp súbor)

• automatické zvýrazňovanie Tools -> Highlighting -> Sources, malo by byť zaškrtnuté C++
• automatické C++ odsádzanie Tools -> Indentation malo by byť zaškrtnuté C Style
• zobrazovanie terminálu
  • Settings -> Configure Kate -> Plugins a tam zaškrtnite Plugin s terminálom
  • View -> Tool Views a zaškrtnite Show Terminal
  • Tools -> Synchronize Terminal with Current Document
• Tools -> align vám preformátuje vybranú časť programu

Kompilovanie a spustenie programu

• Kate nemá vstavané kompilovanie ani spúšťanie (keďže je to textový editor), preto na to treba používať terminál (textové príkazy)
• v Kate viete mať priamo otvorenú lištu s terminálom, čo je veľmi praktické, mala by sa nachádzať dole pod textovým oknom (prípade kliknite na malú ikonku Terminal)
• Kliknite do okna s terminálom, aby sa stalo aktívnym
• v termináli sa treba dostať do priečinku s vaším súborom
  • buď sa to stane automaticky vďaka nastaveniu Tools -> Synchronize Terminal with Current Document
  • alebo použite príkazy nižšie
• Ak sa nachádzate v priečinku, v ktorom sa nachádza váš .cpp program, môžete ho pomocou konzoly kompilovať a spúšťať
• Príkaz make meno_suboru_bez_koncovky - napíšeme meno súboru, ale bez koncovky, v tom istom priečinku sa vytvorí súbor meno_suboru_bez_koncovky, čo bude spustiteľný program (linuxový ekvivalent .exe)
• Príkaz g++ program.cpp -o program - vytvorí to isté ako príkaz pred tým, akurát vieme nastavovať parametre kompilátora g++
• Príkaz ./spustitelny_subor - spustí daný program v priečinku, ak mal niečo vypísať, vypíše to do konzoly, ak mal niečo čítať, načítava to tiež z konzoly (ak nie je povedané inak)

Ďalšia práca s teminálom

• V termináli by ste mali vidieť svoje meno, nejaké ďalšie veci a potom :~$ za ktorým kliká kurzor
• časť za : vám hovorí, v ktorom priečinku sa nachádzate, ~ je domový priečinok
• príkaz ls vypíše zoznam súborov a priečinkov v priečinku, v ktorom ste (skratka z list)
• príkaz cd meno_priečinka - presunie sa do priečinka s daným menom, ak sa taký priečinok nachádza v aktuálnom priečinku (skratka z change directory)
• príkaz cd .. - posuniete sa o jeden priečinok vyššie
• ak budete pri písaní mena priečinka/súboru stláčať Tabulátor, bude sa vám to snažiť automaticky doplniť hľadaný súbor, ak je možností viac, doplní čo najviac znakov, ktoré sú rovnaké
• šípkou hore a dole listujete v histórii príkazov a stlačením Enter ho môžete spustiť znovu

Práca v Kate s grafickou knižnicou SVGdraw

• Knižnicu začneme používať od piatej prednášky
• Stiahnite si knižnicu
  • Stiahnuté súbory SVDdraw.cpp a SVGdraw.h si uložte do priečinku, v ktorom máte svoje programy
• do vlastného programu potom musíte na začiatok pridať riadok #include "SVGdraw.h"

Kompilácia s grafickou knižnicou SVGdraw

• kompilátor potrebuje vedieť, že váš program chce používať funkcie z iného súboru (SVGdraw.cpp) a preto mu musíte povedať, aby ich nalinkoval. Obyčajný make fungovať nebude
• použite príkaz g++ program.cpp SVGdraw.cpp -o program
• vytvorí sa vám súbor program, ktorý môžete normálne spustiť pomocou ./program
• v priečinku s programom sa vytvorí súbor s príponou .svg, ktorý si môžete pozrieť napr. v internetových prehliadačoch firefox alebo chromium

Iné programátorské prostredia

Okrem jednoduchých editorov ako Kate existujú aj zložitejšie prostredia, ktoré podporujú prácu programátora, najmä na väčších projektoch. Zvyknú sa nazývať IDE (integrated development environment). Výhodu je napríklad zabudovaný debugger, ktorý umožňuje krokovať program pri hľadaní chýb.

Viacplatformové prostredia

Nasledovné prostredia by mali fungovať na Linuxových aj Windowsových počítačoch, aj keď nie vždy je ľahké ich nainštalovať a môžu byť tiež pomerne pomalé

• Netbeans
• Eclipse
• Code::Blocks
• CLion, komerčný softvér so študentskou licenciou zadarmo
• Visual Studio Code od firmy Microsoft

Z nich v učebniach v Linuxe fungujú Code::Blocks, Netbeans, Eclipse

• Tieto prstredia teda môžete použiť aj na skúške
• Návod na použitie prostredia Netbeans z minulých semestrov nájdete tu
• Netbeans budeme pravdepodobne používať v letnom semestri na programovanie v Jave

Windows

Pod Windows existuje pomerne veľké množstvo programátorských prostredí podporujúcich C/C++. Možnosti sú napríklad nasledovné:

1. Kompilátor GCC + textový editor

• Ide o najjednoduchšiu možnosť podobnú práci s Kate pod Linuxom.
• GCC je pôvodom Linuxový kompilátor pre C/C++. Existuje však aj verzia pre Windows, ktorá je súčasťou prostredia MinGW.
• Programy možno písať v ľubovoľnom textovom editore, idálne však v takom, ktorý podporuje zvýrazňovanie syntaxe pre C a C++ – napríklad Notepad++, PSPad a mnohé ďalšie.
• Programy potom kompilujeme z príkazového riadku: napríklad súbor program.cpp skompilujeme tak, že sa v príkazovom riadku nastavíme do adresára, ktorý ho obsahuje a následne zadáme príkaz ako

g++ -o program program.cpp

Tým sa vytvorí spustiteľný súbor program.exe, ktorý možno spustiť z príkazového riadku príkazom program.

• Viaceré textové editory podporujú aj integráciu s príkazovým riadkom, takže kompilovanie a spúštanie programov možno realizovať priamo z nich.

Inštalácia MinGW:

• Stiahnite si inštálator zo stránky projektu.
• Zapamätajte si adresár na disku, do ktorého MinGW inštalujete.
• Spustite inštaláciu, počas ktorej zvoľte obidva jazyky C a C++.
• Po ukončení inštalácie pridajte cestu do adresára obsahujúceho spustiteľné súbory gcc.exe a g++.exe (typicky <cesta do koreňového adresára MinGW>\bin) do systémovej premennej PATH, aby bolo možné g++ v príkazovom riadku volať z ľubovoľného adresára. Na internete je dostupných množstvo návodov na editovanie systémových premenných (kľúčové slová pre vyhľadávanie môžu byť napríklad edit PATH environment variable v kombinácii s vašou verziou Windows).

2. NetBeans

• NetBeans je IDE určené najmä pre jazyk Java. Možno v ňom však vyvíjať aj aplikácie pre C a C++.
• Je potrebné mať nainštalované MinGW (viď vyššie) a súčasne aj utilitu MSYS. Je možné nainštalovať aj obidva tieto programy naraz. Po ukončení inštalácie je potrebné okrem cesty na adresár obsahujúci gcc.exe a g++.exe do premennej PATH pridať aj adresár obsahujúci make.exe.
• Podrobný návod na inštaláciu je k dispozícii tu, pričom odporúčame variant s MinGW.

3. Dev-C++

• Iné IDE pre Windows s pomerne bezproblémovou inštaláciou (nepotrebuje MinGW).
• Dostupné je tu.

4. Code::Blocks

• Multiplatformové IDE.
• Dostupné tu.

5. Visual Studio 2015

• Profesionálne komerčné prostredie od firmy Microsoft, ktoré si ako študenti môžete na študijné účely nainštalovať podľa pokynov na fakultnej stránke

Ak máte na počítači operačný systém Windows, ale chceli by ste si vyskúšať aj prácu v Linuxe:

• Môžete si nainštalovať Linux do virtuálneho počítača, napr. pomocou programu VirtualBox.
• Alebo môžete štartovať Linux nainštalovaný na USB kľúči.

On-line prostredia

Ak máte problémy nainštalovať na svoj počítač vhodné prostredie na programovanie, môžete skúsiť webstránky, ktoré vám umožňujú písať, kompilovať a spúšťať jednoduché programy.

• Základná jednoduchá stránka: https://www.codechef.com/ide
• Mierne zložitejšia stránka, v ktorej sa dá program interaktívne spúšťať a dá sa robiť aj s SVGdraw: http://www.tutorialspoint.com/compile_cpp11_online.php

Tieto stránky nebudete môcť používať na skúške.

Kontrola práce s pamäťou programom valgrind

V druhej polovici semestra budeme pracovať aj so smerníkmi a alokáciou pamäte. Na odhalenie chýb, ktoré pri práci s pamäťou vznikajú, môžete použiť program valgrind.

• Návod na použite programu valgrind.

Zimný semester, príklady na test

Na treťom teste budú podobné typy príkladov, aké poznáte z prvých dvoch testov, napríklad

• napíšte funkciu, ktorá robí zadanú činnosť
• doplňte chýbajúce časti funkcie
• zistite, čo funkcia robí (pre daný vstup alebo všeobecne)

Vyskytne sa však aj nový typ príkladov, kde je úlohou napísať, ako bude na nejakom vstupe fungovať algoritmus alebo dátová štruktúra z prednášky. Nižšie sú ukážky takýchto príkladov. Svoje odpovede si môžete skontrolovať na spodku stránky.

Príklady o binárnych vyhľadávacích stromoch a lexikografických stromoch (príklady 7 a 8 nižšie) na riadnom termíne písomky nebudú, môžu sa však vyskytnúť na opravnom termíne.

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

• Príklad 1: Prepíšte výraz 8 3 4 * + 2 3 + / z postfixovej notácie do bežnej infixovej notácie. Aká je jeho hodnota? Nakreslite ho aj ako strom.

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

• Príklad 3: 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 4: 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 5: Strom nižšie má v každom uzle uložené jedno písmeno (dáta typu char). V akom poradí budú vypísané jednotlivé písmená, ak použijeme inorder, preorder a postorder prehľadávanie?

         A
       /  \
      /    \
     B      C  
    / \    / \
   D   E  F   G
      / \
     H   I

• 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 stromu 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 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?

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

• Príklad 1: (8+3*4)/(2+3), hodnota 4, strom:

         /
       /  \
      /    \
     +      +  
    / \    / \
   8   *  2   3
      / \
     3   4

• Príklad 2: postfix 2 4 + 3 5 * / 1 2 - / prefix: / / + 2 4 * 3 5 - 1 2
• Príklad 3: 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 4: na zásobníku budú znaky A, D, C (A na spodku zásobníka), v rade bude písmeno B
• Príklad 5:

Preorder:  ABDEHICFD
Postorder: DHIEBFGCA
Inorder:   DBHEIAFCG

• Príklad 6:

        #
       / \
      #   *
     /\
    *  #
      /\
     *  *

• Príklad 7:

        3
       / \
      1   4
      \    \
       2    5
             \
              6

• Príklad 8: (namiesto dvojitého krúžku používame *)

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

• Príklad 9:

Pre každý index tabuľky 0,..,4 uvádzame zoznam prvkov, ktoré sa do neho zahešujú. Tieto budú pospájané v zozname v uvedenom poradí.

0: 10, 0
1:
2: 17, -2
3: 8, 13
4:

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 a v prostredí Kate
• Stiahnutie knižnice
• Príklady programov na prednáške 5

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

Testovač

Príklady z cvičení, domácich úloh, ale aj na záverečnej skúške budete odovzdávať na stránke http://prog.dcs.fmph.uniba.sk/ , ktorá bude súčasne mnohé z vašich riešení aj testovať.

• Na stránku sa prihláste heslom, ktoré dostanete na prvých cvičeniach, po prihlásení si ho zmeňte.
• Na testovači uvidíte zoznam príkladov, spolu s ich zadaniami v pdf formáte a s ďalšími potrebnými súbormi (napr. kostra programu, príklady vstupu)
• Vaše programy môžete odovzdať buď zvolením súboru s programom (.cpp) z disku alebo nakopírovaním programu pomocou myši do textového poľa.
• Váš program sa uloží na testovači a môžete si neskôr skontrolovať, či ste odovzdali správnu verziu.
• Testovač váš program skompiluje a spustí na niekoľkých vstupoch. Výsledok testovania vám zobrazí.
• V závislosti od zaťaženia servera zobrazenie výsledku môže nejaký čas trvať.
• V ideálnom prípade dostanete výsledok OK, ak váš program vypísal na všetkých vstupoch správnu odpoveď.
• Môže však dôjsť k rôznym chybám:
  • CE (compile error): chyba pri kompilácii, testovač vypíše výstup kompilátora. Odporúčame pred odovzdaním program skompilovať na vašom počítači.
  • WA (wrong answer): na niektorom vstupe váš program vypísal zlú odpoveď. Môže ísť o závažnú chybu v programe, ale aj len o malý problém vo formáte výstupu. Testovač väčšinou porovnáva váš výsledok znak po znaku so správnym výsledkom a každý rozdiel, ako napríklad medzera navyše, považuje za chybu. Pozrite si detaily testovania, či nezbadáte rozdiely vo formáte.
  • TO (time limit exceeded): program na príslušnom vstupe bežal príliš dlho. Nakoľko dávame pomerne veľké časové limity, pravdepodobne váš program sa "zacyklil", t.j. beží do nekonečna.
  • SG (segmentation fault): váš program spadol na chybu pri behu, napr. delenie nulou, prístup mimo hraníc poľa, prípadne priveľká spotreba pamäte.
  • Kód WAITING znamená, že váš program ešte čaká na spustenie a RUNNING znamená, že prebieha jeho testovanie.
• Pri týchto problémoch skúste program spúšťať na viacerých vstupoch na vašom počítači a chybu objaviť. Niekedy vám poskytneme aj vstupy a výstupy použité na testovači, ktoré vám pomôžu pri hľadaní chyby. V opačnom prípade si skúste nejaké vstupy vymyslieť sami.
• Program opravujte až kým nedostanete OK na všetkých vstupoch.
• Testovač vám dovolí odovzdať program aj po termíne, ale takéto pokusy už nebudú brané do úvahy pri bodovaní, pokiaľ nemáte dohodnuté individuálne predĺženie termínu s vyučujúcimi.
• Ak testovač nefunguje alebo ak nájdete chybu v zadaní, dajte nám vedieť na adrese Takisto na túto adresu posielajte otázky k zadaniam alebo prosby o pomoc s konkrétnou úlohou.

Poznámka o vstupe a výstupe

• Ak v zadaní nie je povedané inak, všetok vstup načítavajte z konzoly príkazmi cin (prípadne scanf a pod.) a vypisujte na konzolu príkazmi cout (prípadne printf a pod.)
• Vstup uvedený v zadaní má testovač v súbore a presmeruje ho vášmu programu na konzolu, t.j. správa sa podobne, ako keby niekto zadával príslušné hodnoty ručne počas behu vášho programu
• Naopak testovač zachytí do súboru všetko, čo váš program vypíše na konzolu. Tento súbor potom porovnáva so správnou odpoveďou.
• Napr. program na sčítanie čísel z prvej prednášky by mohol mať nasledovný vstup a výstup na testovači:

10
3

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

• V príkladoch na testovači väčšinou vynecháme interaktívne časti, program si teda nebude pýtať čísla od užívateľa, predpokladá, že ten ich sám od seba zadá.

Prednáška 1

Pozrite si úvod k predmetu a pravidlá.

Organizačné poznámky

• Zajtra budú hlavné cvičenia s prvými bodovanými príkladmi
  • Úvod do cvičenia spoločne v I-H6, potom sa rozdelíme do I-H6, I-H3
  • Oboznámenie sa s prostredím, s testovačom, riešenie jednoduchých príkladov k prvej prednáške
  • Budete potrebovať prihlasovacie meno a heslo do AIS2 na prihlásenie na počítač v učebni
  • Aspoň na úvod cvičenia odporúčame prísť aj pokročilým
• V stredu druhá prednáška, v piatok doplnkové cvičenia
• Do zajtra sa v prípade záujmu prihláste na test pre pokročilých
• Test pre pokročilých bude v stredu večer
• Ak si neviete C++ nainštalovať na notebook, prineste ho na doplnkové cvičenia niektorý piatok, skúsime pomôcť

Programátorské prostredie

• Na tomto predmete budeme programovať v jazyku C++, budeme však z neho používať len malú časť
• Budeme používať editor Kate
• 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
  • viac informácií na stránke o alternatívach ku Kate

• Potrebné nástroje si môžete nainštalovať zadarmo aj na vašom počítači alebo môžete mimo rozvrhu používať školské učebne

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 v návode na prácu s editorom Kate

Ďalší jednoduchý program

• Podobným spôsobom môžeme vypísať aj iný text. Napríklad dnešný dátum:

#include <iostream>
using namespace std;

int main(void) {
    cout << "Dnes je 23.9.2019!" << endl;
}

• Cvičenie: Rozšírte program tak, aby na druhý riadok vypísal dátum v americkom formáte mesiac/deň/rok.

Premenné

Príklad z cvičenia by mohol vyzerať napríklad takto:

#include <iostream>
using namespace std;
int main(void) {
    cout << "23.9.2019" << endl;
    cout << "9/23/2019" << endl;
}

Ak by sme v ňom chceli zmeniť dátum na prvú prednášku o rok, museli by sme pomeniť vhodné čisla na dvoch miestach. Navyše keď vidíme v programe nejaké číslo, nemusí byť úplne jasné, čo znamená.

Program teraz prepíšeme tak, aby sme deň, mesiac a rok mali zapísané symbolicky a mohli ich meniť na jednom mieste.

#include <iostream>
using namespace std;
int main(void) {
    int den = 23;
    int mesiac = 9;
    int rok = 2019;

    cout << den << "." << mesiac << "." << rok << endl;
    cout << mesiac << "/" << den << "/" << rok << endl;
}

Symbolickým hodnotám den, mesiac, rok sa hovorí premenné.

• Premmená je 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.

Ak v programe premenným priradíme iné čísla, môžeme vypísať iný dátum.

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

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.

• 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
  • načítanie, ktoré nám umožní získať dáta od používateľa
  • 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

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

Sčítanie čísel

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 znamienko 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 a 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?

Prednáška 2

Oznamy

Zopakovanie ako fungujú cvičenia:

• Na začiatku cvičení v utorok sa na testovači objaví nová sada úloh
• Prvá úloha je rozcvička, treba ju odovzdať do konca cvičenia, začnite teda touto úlohou
• Zvyšok cvičenia riešte ďalšie úlohy
• Čo nestihnete na cvičení, môžete dokončiť doma alebo na doplnkových cvičeniach v piatok, termín odovzdania je začiatok ďalšieho cvičenia
  • Odovzdávať sa dajú aj úlohy po termíne, ale nedostanete za ne body, ak sme vám neudelili výnimku
• V piatok príďte na cvičenia, ak vám zostalo veľa príkladov z utorka alebo sa vám zdajú ťažké, takže sa vám zíde pomoc. Tiež ak máte otázky k domácej úlohe alebo k učivu všeobecne.
• Obvykle nebudú cvičenia predbiehať prednášky, výnimka bola tento týždeň (príklady 4-6)
• Body za prvé cvičenia sa objavia na testovači koncom budúceho týždňa, ale zväčša dostanete body za všetky príklady, kde testovač dal ok.
• Príklady z cvičení môžete riešiť aj v dvojiciach, odovzdá jeden a pri odovzdaní vypíše prihlasovanie meno partnera
  • výhody: poučíte sa z toho, čo vie váš partner, menej stresu, pair programming sa niekedy používa aj vo firmách
  • nevýhody: nenaučíte sa úlohy riešiť samostatne (treba na skúške, neskôr v štúdiu aj v práci), skúšajte teda občas pracovať aj jednotlivo, v rámci páru buďte aktívni a pýtajte sa, ak nerozumiete, čo partner robí
  • na DÚ máte pracovať jednotlivo, nie v pároch (prvá DÚ bude zverejnená v treťom týždni semestra)

Najbližšie dni na programovaní

• Dnes prednáška, ďalšie dve prednášky budúci týždeň
• Dnes nepovinný test pre pokročilých (ak ste sa prihlásili)
• Doplnkové cvičenia v piatok
• Budúci utorok ďalšie cvičenia s ďalšou sadou úloh (k prednáške dnes a v pondelok)

Technické záležitosti

• Na stránke Softvér nájdete príklady ďalších programov, ktoré môžete použiť namiesto Kate.
• Ak sa vám páči Kate, prečítajte si časť o Kate a práci na príkazovom riadku. Vo Windows si môžete nainštalovať podobný editor, napr. Notepad++.
• Ak by ste chceli viac klikacie prostredie, môžete skúsiť napríklad program Netbeans, dá sa použiť aj na skúške a možno ho budeme používať budúci semester. Mal by sa dať nainštalovať aj vo Windows.
• Na svojom počítači máte širokú paletu možností, v čom programovať, aspoň občas ale skúste použiť Linux na cvičeniach, aby ste vedeli robiť skúšku (Kate alebo Netbeans alebo iné nástroje, nie však internetové prostredia).

Opakovanie

Doteraz sme videli:

• Načítavanie pomocou cin, výpis pomocou cout.
• Celočíselné premenné typu int.

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

Komentáre

Do zdrojových kódov programov v jazykoch C a C++ je možné pridávať komentáre, čo sú časti kódu ignorované kompilátorom.

• Komentár je časť programu začínajúca /* a končiaca */ (aj cez viac riadkov)
• Komentár je aj text od // až po koniec riadku. To je užitočné na písanie krátkych komentárov.

Do komentárov sa zvyknú písať poznámky k významu okolitých príkazov, čo zlepšuje orientáciu v kóde a jeho pochopenie inými programátormi.

Ukážka komentárov:

#include <iostream>
using namespace std;

int main() {
    cout << "Som program s komentarmi." << endl; // Som komentar na jeden riadok.
    /* Som komentar
       na
       velmi
       vela
       riadkov
    */
}

A zmysluplnejšie použitie:

#include <iostream>
using namespace std;

/* Tento program od pouzivatela nacita dve cele cisla
 * a vypise ich sucet. */

int main(void) {
    // vytvorime premenne x a y
    int x, y;

    // do premennych od pouzivatela nacitame cisla
    cout << "Please enter the first number: ";
    cin >> x;
    cout << "Please enter the second number: ";
    cin >> y;

    // do novej premennej result spocitame vysledok
    int result = x + y;
    // vysledok vypiseme
    cout << x << "+" << y << "=" << result << endl;
}

Podmienka (if)

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

• Nasledujúci program si vypýta od užívateľa číslo a vypíše, či je toto číslo záporné alebo nezáporné.

#include <iostream>
using namespace std;

int main(void) {
    int x;
    cout << "Zadajte cislo: ";
    cin >> x;

    if (x < 0) {
        cout << "Cislo " << x << " je zaporne." << endl;
    } else {
        cout << "Cislo " << x << " je nezaporne." << endl;
    }
}

• Tu je príklad dvoch behov programu:

Zadajte cislo: 10
Cislo 10 je nezaporne.

Zadajte cislo: -3
Cislo -3 je zaporne.

• Ako vidíme, za príkazom if je zátvorka s podmienkou. V našom príklade podmienka je x < 0.
• Ak je podmienka v zátvorke splnená (t.j. ak x je menšie ako nula), vykonáme príkazy v zloženej zátvorke za príkazom if.
• Ak podmienka nie je splnená (t.j. ak je x väčšie alebo 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.
• Ak za if alebo else nasleduje iba jeden príkaz, zátvorky { a } môžeme vynechať. To však ľahko vedie k chybám, preto je lepšie ich vždy použiť.

Cvičenie:

• Pomocou podmienky vypíšte absolútnu hodnotu načítaného čísla.
• Namiesto vypísania uložte túto hodnotu do premennej y, ktorá by sa dala ďalej v programe použiť.

Dátové typy int, double a bool

Na začiatok budeme pracovať s troma dátovými typmi:

• typ int pre celé čísla – príkladmi konštánt typu int sú 1, 42, -2, alebo 0.
• typ double pre reálne čísla – príkladmi konštánt typu double sú 4.2, -3.0, 3.14159, alebo 1.5e3 (1.5e3 je tzv. semilogaritmický zápis znamenajú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 1,5 \cdot 10^3} , t.j. 1500).
• typ bool pre logické hodnoty – jedinými konštantami sú true (ekvivalentná číselnej hodnote 1) a false (ekvivalentná číselnej hodnote 0).

Premenné typu int a double zaberajú pevne daný počet bitov, preto do nich nie je možné uložiť ľubovoľné celé alebo reálne číslo. Presný rozsah možných hodnôt môže závisieť od kompilátora, v súčasnosti však väčšinou platí:

• Typ int zvyčajne zaberá 4 bajty (32 bitov) a dajú sa ním reprezentovať celé čísla z intervalu <-2 147 483 648, +2 147 483 647>.
• Typ double zvyčajne zaberá 8 bajtov. Ním reprezentované reálne čísla sú v pamäti uložené 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. Typ double tak možno použiť na prácu s reálnymi číslami približne 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 číslic. Pri tejto reprezentácii sa nevyhradzujú pevné počty bitov na reprezentáciu celej a desatinnej časti; počet cifier pred a za rádovou čiarkou je určený exponentom. Hovoríme preto o pohyblivej rádovej čiarke.

Pretypovanie

Hodnotu niektorého z typov bool, int, double je možné skonvertovať na „zodpovedajúcu” hodnotu ľubovoľného ďalšieho z týchto typov. V takom prípade hovoríme o pretypovaní. Platí pritom nasledujúce:

• Konverzia z „menej všeobecného” typu na „všeobecnejší” sa správa očakávateľným spôsobom. Booleovské hodnoty false resp. true sa konvertujú na celé čísla 0 resp. 1, prípadne na reálne čísla 0.0 resp, 1.0; celé číslo sa tiež konvertuje na reálne číslo, ktoré je mu rovné.
• Konverzia zo „všeobecnejšieho” typu na „menej všeobecný” dodržiava určité vopred stanovené pravidlá. Napríklad pri konverzii z int alebo double na bool sa ľubovoľná nenulová hodnota skonvertuje na true a nula sa skonvertuje na false. Pri konverzii z double na int dôjde k zaokrúhleniu smerom k nule (čiže nadol pri kladných číslach, nahor pri záporných).

Pretypovanie je možné realizovať dvoma spôsobmi:

• Implicitne, napríklad priradením premennej jedného typu do premennej iného typu, alebo použitím premennej jedného typu v kontexte, kde sa očakáva premenná druhého typu.
• Explicitne, použitím pretypovacieho operátora: (nazov_noveho_typu) vyraz_stareho_typu.

Možnosti pretypovania sú ilustrované nasledujúcim ukážkovým programom.

#include <iostream>
using namespace std;

int main() {
  bool b1 = true;
  int n1 = 4;
  double x1 = 1.234;

  bool b2;
  int n2;
  
  b2 = n1; // b2 = 1
  n2 = x1; // n2 = 1 
  cout << b2 << " " << n2 << endl; // Vypise 1 1
  
  x1 = n2; // x1 = 1.0
  cout << x1 << endl; // Vypise 1
  
  cout << (bool) 7 << " " << (bool) 0 << endl; // Vypise 1 0 
  cout << (int) 4.2 << " " << (int) -4.2 << endl; // Vypise 4 -4
  
}

Aritmetické operátory a výrazy

Na typoch int aj double sa dajú robiť základné aritmetické operácie

• sčítanie+
• odčítanie -
• násobenie *
• delenie /

Operátor / sa na argumentoch typu int správa ako celočíselné delenie – hodnota podielu sa zaokrúhli smerom k nule.

• Napríklad výraz 5/3 má hodnotu 1.
• Akonáhle je však aspoň jeden operand typu double, interpretuje sa / ako delenie reálnych čísel.
• Výrazy 5.0/3.0, 5.0/3, 5/3.0 a 5/(double)3 teda majú všetky hodnotu 1.66667.

#include <iostream>
using namespace std;

int main() {
    int a = 4;
    int b = 3;
    double d = 3; // Automaticky pretypuje cele cislo 3 na realne cislo 3.0

    cout << a / b << endl; // Celociselne delenie: 4 / 3 = 1
    cout << a / d << endl; // Necelociselne delenie: 4 / 3.0 = 1.33333
    cout << (1.0 * a) / b << endl; // Necelociselne delenie: (1.0 * 4) / 3 = 4.0 / 3 = 1.33333
    cout << ((double)a) / b << endl; // Necelociselne delenie: 3.0 / 4 = 1.33333 
    
    double e = a / b; // Do e je priradeny vysledok celociselneho delenia 4 / 3 = 1; po pretypovani je to rovne 1.0
    cout << e << endl; // Vypise 1
    cout << e / 2 << endl; // Vypise 0.5, lebo 1.0 / 2 je necelociselne delenie  
}

• Na celých číslach je definovaný operátor %, ktorého výstupom je zvyšok po celočíselnom delení. Napríklad výraz 5%3 má hodnotu 2.
• Ďalšie matematické operácie a funkcie vyžadujú #include <cmath> (pre jazyk C++) 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ť), ...
  • Viac detailov možno nájsť v dokumentácii.

Relačné operátory

Hodnoty typov int, double a bool možno porovnávať nasledujúcimi relačnými operátormi:

• == pre rovnosť;
• != pre nerovnosť;
• < pre reláciu „menší ako”;
• > pre reláciu „väčší ako”;
• <= pre reláciu „menší alebo rovný ako”;
• >= pre reláciu „väčší alebo ako”.

Výstupom relačného operátora je logická hodnota true alebo false.

Logické operátory a výrazy

Na výrazoch typu bool sú definované logické operátory, ktoré sa správajú rovnako ako logické spojky známe z výrokovej logiky:

• || pre disjunkciu (or, alebo);
• && pre konjunkciu (and, a súčasne);
• ! pre negáciu (not, opak)

Logickým výrazom je napríklad !((x >= 2) && (x <= 4)) alebo !true.

Operátory priradenia, inkrementu a dekrementu

Operátor priradenia premenna = hodnota už poznáme. Často realizovanou operáciou na číslach je zvýšenie hodnoty o 1. To možno urobiť napríklad nasledujúcimi spôsobmi:

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

Analogicky sú definované operátory ako --, -=, *=, atď.

Priorita a asociativita operátorov

Výrazy sa vyhodnocujú v nasledujúcom poradí preferencie jednotlivých operátorov. Operátory v jednom riadku majú rovnakú prioritu a operátory vo vyššom riadku majú vyššiu prioritu, než operátory v nižších riadkoch.

• ++ (inkrement), -- (dekrement), ! (logická negácia)
• *, /, %
• +, -
• <, >, <=, >=
• ==, !=
• && (logická konjunkcia)
• || (logická disjunkcia)
• = (priradenie)

Poradie vyhodnocovania je možné meniť zátvorkami, ako napríklad vo výraze 4*(5-3).

Uvedené operátory sa väčšinou vyhodnocujú zľava doprava (hovoríme, že sú zľava asociatívne) – napríklad 1 - 2 - 3 sa teda vyhodnotí ako (1 - 2) - 3, t.j. -4 a nie ako 1 - (2 - 3), t.j. 2. Výnimkou sú operátory !, ++, -- a =, ktoré sú sprava asociatívne. To umožňuje napríklad viacnásobné priradenie a = b = c, ktoré najprv priradí hodnotu c do b a následne hodnotu výrazu b = c – tou je nová hodnota premennej b, čiže hodnota premennej c –, do a.

Viac sa o operátoroch v C++ možno dočítať napríklad tu.

Viac o podmienkach

Vnorené podmienky

Príkazy if môžeme navzájom vnárať. Príklad: načítaj číslo 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 << "Zero" << endl;
    } else {
        if (x > 0) {
            cout << "Positive" << endl;
        } else {
            cout << "Negative" << endl;
        }
    }

}

Logické výrazy môžu byť efektívnym nástrojom na elimináciu množstva vnorených podmienok: napríklad konštrukcia typu

if (a == 0) {
    if (b == 0) {
        čokoľvek
    }
}

je ekvivalentná konštrukcii

if (a == 0 && b == 0) {
    čokoľvek
}

Upozornenie

Častou chybou je použitie priradenia namiesto porovnania. Nasledujúci kúsok programu do premennej x priradí nulu, ktorá sa premení na false pre účely vyhodnotenia podmienky.

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

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

Cvičenia

• Napíšte program, ktorý načíta čísla a,b,c a vypíše, či sú usporiadané vzostupne, t.j. či platí a<b<c
  • Pozor, výraz a<b<c treba rozpísať na dve porovnania spojené logickou spojkou

Cyklus for

Dôležitou časťou programovania je schopnosť opakovanie vykonávať tie isté príkazy. Prvou možnosťou ako to robiť, je cyklus for.

Príklad 1: vypisovanie čísel od 1 po n

Nasledujúci program načíta zo vstupu číslo n a postupne vypíše prirodzené čísla od 1 po n (pred každé dá medzeru).

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cout << " " << i;
    }
    cout << endl;
}

Tu je výstup programu pre n = 9:

 1 2 3 4 5 6 7 8 9

Cyklus for vyzeral v programe takto:

for (int i = 1; i <= n; i++) {
    telo cyklu
}

Táto konštrukcia pozostáva z kľúčového slova for nasledovaným zátvorkou s troma časťami oddelenými bodkočiarkami:

• Príkaz int i = 1 vytvorí novú celočíselnú premennú i a priradí jej hodnotu 1.
• Podmienka i <= n určuje dokedy sa má cyklus opakovať. V tomto prípade to má byť kým je hodnota premennej i menšia alebo rovná n.
• Príkaz i++ hovorí, že po každom zopakovaní cyklu (t.j. po každej jeho iterácii) sa má hodnota premennej i zvýšiť o jedna.
• Medzi zloženými zátvorkami { a } je potom tzv. telo cyklu – čiže jeden alebo viac príkazov, ktoré sa budú opakovať postupne pre rôzne hodnoty premennej i.

V príklade 1 je telom cyklu iba príkaz cout << " " << i;, ktorý vypíše medzeru a hodnotu premennej i.

Príklad 2: vypisovanie čísel od 0 po n-1

Drobnou zmenou predchádzajúceho programu môžeme napríklad vypísať všetky čísla od 0 po n-1:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    for (int i = 0; i < n; i++) {
        cout << " " << i;
    }
    cout << endl;
}

Tu je výstup programu pre n = 9:

 0 1 2 3 4 5 6 7 8

Príklad 3: výpočet faktoriálu

Nasledujúci program si od používateľa vypýta číslo n a vypočíta n!, t.j. súčin celých čísel od 1 po n.

#include <iostream>
using namespace std;

int main() {
    int n;
    
    cout << "Zadajte n: ";
    cin >> n;
    
    int vysledok = 1;
    for (int i = 1; i <= n; i++) {
       vysledok = vysledok * i;
    }
    
    cout << n << "! = " << vysledok << endl;
}

Príklad behu programu pre n=4 (1*2*3*4=24):

Zadajte n: 4
4! = 24

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

Funkcia n! však 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 (ktoré možno získať zmenou typu premennej vysledok na long long int) sú:

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

Cvičenie: rozšírte program tak, aby okrem výpisu výsledku aj rozpísal faktoriál ako súčin:

Zadajte n: 4
4! = 1*2*3*4 = 24

Zhrnutie

Poznáme základné stavebné prvky, z ktorých sa dajú spraviť aj pomerne zložité programy:

• premenné typu int, double, bool a operátory, ktoré s nimi vedia počítať
• podmienku if, ktorá umožňuje vykonávať určité časti programu len za nejakých okolností
• cyklus for, ktorý umožnuje opakovať určité časti programu veľa krát

Cieľom najbližšej prednášky a cvičení je hlavne precvičiť si tieto stavebné prvky na veľa ďalších príkladoch.

Cvičenia 1

Cieľom prvých cvičení je:

1. vyskúšať si prihlásenie na počítače v učebni a prácu v prostredí Kate, prípadne v iných prostrediach
2. precvičiť si písanie jednoduchých programov
3. vyskúšať si prácu s testovačom

Príklad 0: Sčítanie čísel

• Zapnite počítač, zvoľte Linux, prihláste sa heslom ako do AIS
• Otvorte si stránku predmetu http://compbio.fmph.uniba.sk/vyuka/prog/, nájdite prvé cvičenia (tento text)
• Spustite editor Kate podľa návodu tu
• Skopírujte si Program na sčítanie čísel z prvej prednášky
• Skúste ho skompilovať a spustiť.

Príklad 1: odovzdávanie na testovači domácich úloh

• Prihláste sa na testovač, zmeňte si heslo
• Pozrite si Návod na prácu s testovačom
• Nájdite si zadanie príkladu 1 na testovači, je to len malá modifikácia sčítania dvoch čísel
  • Rozdiel je, že testovaču nebudeme vypisovať, aby zadal číslo a na výstupe vypíšeme iba samotný súčet.
• Zmodifikujte program podľa požiadaviek zadania a odovzdajte ho na testovači
  • Pozrite si výsledky testovania, ak nedostanete odpoveď OK, skúste chybu opraviť
• Tento príklad je rozcvička, body zaňho dostanete, len ak ho dokončíte počas cvičenia

Ďalšie bodované príklady

• Ďalšie zadania na tento týždeň nájdete priamo na testovači. Prvé tri príklady sa týkajú pondelkovej prednášky, ďalšie tri už potrebujú učivo zo stredy.
• Ak ste všetky príklady nevyriešili, odporúčame vám prísť na doplnkové cvičenia v piatok a pokračovať v ich riešení
• Môžete ich riešiť aj doma, až do začiatku cvičení budúci utorok
• Tento týždeň na doplnkových cvičeniach ešte nebude rozcvička za bonusové body

Prednáška 3

Oznamy

• V pondelok 7. októbra bude v čase prednášky teoretické cvičenie, na ktorom sa bude (na papier) písať krátky test zameraný na praktické znalosti učiva preberaného na prvých troch prednáškach. Za tento test sa budú udeľovať body v rámci hodnotenia cvičení č. 2 (úspešní riešitelia testu pre pokročilých sa teda testu zúčastniť nemusia). Na teste bude povolené používať ťahák vo forme jedného obojstranne popísaného listu A4, žiadne ďalšie pomôcky však povolené nebudú.

Opakovanie: vypisovanie čísel od 1 po n

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cout << " " << i;
    }
    cout << endl;

    return 0;
}

Ďalšie príklady na cyklus for

Príklad č. 1: simulovanie hodov kocky

Nasledujúci program od používateľa načíta číslo n a vypíše n simulovaných hodov kocky (každý na samostatný riadok).

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

int main(void) {
    srand(time(NULL)); // Inicializacia generatora pseudonahodnych cisel
 
    int n;
    cout << "Zadajte pocet hodov: ";
    cin >> n;
    
    for (int i = 1; i <= n; i++) {
        cout << rand() % 6 + 1 << endl; // Vygenerovanie a vypisanie hodu kockou
    }
  
    return 0;
}

Príklad behu programu:

Zadajte pocet hodov: 6
2
6
1
2
1
4

• Program využíva funkciu 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.) Aby bolo možné použiť túto funkciu, treba do hlavičky pridať #include <cstdlib>.
  • Výstupom funkcie rand() je nezáporné celé číslo medzi nulou a nejakou veľkou konštantou.
  • Zvyšok po delení tohto čísla šiestimi, t.j. rand() % 6, je potom číslo medzi 0 a 5. Ak k tomu pripočítame 1, dostaneme číslo od 1 po 6.
• Funkcia srand inicializuje generátor pseudonáhodných čísel na základe parametra „určujúceho bod pseudonáhodnej postupnosti”, počnúc ktorým sa budú jej hodnoty generovať. My ako tento parameter používame aktuálny čas (v sekundách od začiatku roku 1970), čo zaručuje dostatočný efekt náhodnosti. Aby bolo možné použiť funkciu time, je treba do hlavičky pridať #include <ctime>.

Príklad č. 2: vypisovanie deliteľov (podmienka v cykle)

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

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Zadajte cislo: ";
    cin >> n;
    
    cout << "Delitele cisla " << n << ":";
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            cout << " " << i;
        }
    }    
    cout << endl;
    return 0;
}

Príklad behu programu:

Zadajte cislo: 30
Delitelia cisla 30: 1 2 3 5 6 10 15 30

Cyklus while

Schéma cyklu while

Okrem cyklu for možno v jazykoch C/C++ používať aj cyklus while s nasledujúcou schémou:

while (podmienka) { 
    telo cyklu 
}

Telo takéhoto cyklu sa vykonáva, kým je podmienka cyklu splnená. Presnejšie sa pri vykonávaní cyklu while typicky deje nasledovné:

1. Overí sa, či je podmienka cyklu splnená.
2. Ak áno, vykoná sa telo cyklu a celý proces sa opakuje (čiže sa opätovne vykoná overenie podmienky z bodu 1, atď.).
3. Ak nie, vykonávanie programu pokračuje prvým príkazom nasledujúcim za cyklom while.

Príklad č. 1: Vypisovanie čísel od 1 po n po druhé

Program z minulej prednášky, vypisujúci všetky prirodzené čísla od 1 po n, môžeme napísať aj pomocou cyklu while:

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cin >> n;
    
    int i = 1;            // Premenna i bude obsahovat aktualne vypisovane cislo; prve bude 1
    while (i <= n) {      // Kym je cislo i mensie ako n ...
        cout << " " << i; // ... vypis cislo i ...
        i++;              // ... a pokracuj cislom o 1 vacsim
    }
    cout << endl;
    
    return 0;
}

Príklad č. 2: Úroky v banke

Predpokladajme, že na začiatku každého roku pravidelne uložíme na účet v banke nejakú pevnú sumu (napríklad 1000 EUR). Na konci každého roku sa vklad zúročí daným ročným úrokom (napríklad 5%). Za koľko rokov úspory dosiahnu danú cieľovú čiastku (napríklad 10000 EUR)?

Túto úlohu možno riešiť programom pracujúcim na báze nasledujúcej myšlienky:

• Na začiatku ubehlo nula rokov sporenia a na účte nie sú vložené žiadne peniaze.
• Následne v každom roku vložíme na účet pravidelný vklad; na konci roka sa úspory zúročia.
• Toto opakujeme, kým suma na účte nie je rovná aspoň cieľovej čiastke.

To môžeme vyjadriť pomocou cyklu while.

#include <iostream>
using namespace std;

int main(void) {
    double vklad, ciel, urok;
        
    cout << "Zadaj kazdorocny vklad: ";
    cin >> vklad;
    cout << "Zadaj cielovu ciastku: ";
    cin >> ciel;
    cout << "Zadaj rocny urok: ";
    cin >> urok;
    
    int rok = 0;
    double ciastka = 0;
    
    while (ciastka < ciel) {
        rok++;                   
        ciastka = (ciastka + vklad) * (1 + urok / 100);
        cout << "Na konci roku " << rok << " je na ucte " << ciastka << " EUR." << endl;  
    }
    
    return 0;
}

Ukážkový vstup a výstup:

Zadaj kazdorocny vklad: 1000
Zadaj cielovu ciastku: 10000
Zadaj rocny urok: 5
Na konci roku 1 je na ucte 1050 EUR
Na konci roku 2 je na ucte 2152.5 EUR
Na konci roku 3 je na ucte 3310.12 EUR
Na konci roku 4 je na ucte 4525.63 EUR
Na konci roku 5 je na ucte 5801.91 EUR
Na konci roku 6 je na ucte 7142.01 EUR
Na konci roku 7 je na ucte 8549.11 EUR
Na konci roku 8 je na ucte 10026.6 EUR

Príklad č. 3: Euklidov algoritmus

Euklidov algoritmus slúži na hľadanie najväčšieho spoločného deliteľa dvojice kladných celých čísel a, b.

• To znamená: hľadáme najväčšie kladné prirodzené číslo d, ktoré delí súčasne a aj b.
• Najväčší spoločný deliteľ čísel a, b označujeme gcd(a,b) (z angl. greatest common divisor). V slovenčine sa niekedy možno stretnúť aj s označením nsd(a,b).
• Ide o jeden z najstarších známych algoritmov vôbec. Jeho variant popísal už Euklides v diele Základy okolo roku 300 pred Kr.

Príklad:

• Delitele čísla 12 sú 1, 2, 3, 4, 6, 12.
• Delitele čísla 8 sú 1, 2, 4, 8.
• Spoločné delitele 8 a 12 teda sú 1, 2, 4.
• Najväčší spoločný deliteľ čísel 8 a 12 je teda gcd(8,12) = 4.

Euklidov algoritmus je založený na platnosti nasledujúcej lemy.

Lema. Pre všetky kladné celé čísla a, b platí:

1. Ak a mod b = 0, tak gcd(a,b) = b.
2. Ak a mod b ≠ 0, tak gcd(a,b) = gcd(b, a mod b).

Dôkaz.

• Prvé tvrdenie je zrejmé, stačí dokázať druhé.
• Nech X je množina spoločných deliteľov a a b, nech Y je množina spoločných deliteľov b a a mod b. Zrejme stačí dokázať rovnosť X = Y.
• Ak označíme r := a mod b, tak existuje nezáporné celé číslo q také, že a = q b + r.
• Ak 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 \in Y} , číslo x delí b aj r a z rovnosti a = q b + r vyplýva, že delí aj a. Teda 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 \in X} .
• Ak naopak 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 \in X} , číslo x delí a aj b a z rovnosti r = a - qb vyplýva, že delí aj r. Preto 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 \in Y} .
• Dokázali sme teda, že 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 X \subseteq Y} a súčasne 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 \supseteq Y} . Preto X = Y. ◻

Hodnotu gcd(a,b) teda možno nájsť Euklidovým algoritmom takto:

1. Ak a mod b = 0, nutne gcd(a,b) = b.
2. V opačnom prípade vypočítame rovnakým spôsobom hodnotu gcd(b, a mod b).

(Všimnime si, že v bode 2 pre a < b platí a mod b = a, takže obidva argumenty sa iba vymenia. Prípad a = b tu nastať nemôže, lebo v takom prípade je splnená podmienka z bodu 1. Ak nakoniec a > b, nutne a mod b < b, takže prvý argument už bude aj naďalej väčší ako ten druhý. Keďže navyše b < a a a mod b < b, sú obidva argumenty oproti pôvodným aspoň o 1 menšie. To garantuje, že sa Euklidov algoritmus v konečnom čase zastaví.)

Implementácia tohto algoritmu teda môže vyzerať nasledovne:

#include <iostream>
using namespace std;

int main(void) {
    int a,b;    
    cout << "Zadaj dvojicu kladnych celych cisel: ";
    cin >> a >> b;
    
    while (b != 0) {
        int r = a % b;
        a = b;
        b = r;
    }
    
    cout << "Najvacsi spolocny delitel je " << a << "." << endl;

    return 0;
}

Príklad behu programu:

Zadaj dvojicu kladnych celych cisel: 30 8
Najvacsi spolocny delitel je 2.

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

30 8
8 6
6 2
2 0

Príklad č. 4: Nekonečný cyklus

V cykle while typu

while (true) {
    telo cyklu
}

je podmienka stále splnená; telo cyklu sa teda opakuje donekonečna resp. kým program nezastavíme (v prípade, že cyklus neukončíme umelo príkazom break, ktorým sa budeme zaoberať neskôr).

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

Príklad č. 5: 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 (až kým nakoniec neuhádne).

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

int main(void) {
    srand(time(NULL));

    int num = rand() % 100 + 1;
    cout << "Myslim si cislo od 1 po 100. Tvoj tip: ";
    
    bool correct = false;

    while (!correct) {
        int guess;
        cin >> guess;
        if (guess < num) {
            cout << "Prilis nizko. Iny tip: ";
        } else if (guess > num) {
            cout << "Prilis vysoko. Iny tip: ";        
        } else {
            correct = true;
            cout << "Spravne!" << endl;
        }
    }
    return 0;
}

Príklad behu programu:

Myslim si cislo od 1 po 100. Tvoj tip: 50
Prilis nizko. Iny tip: 70
Prilis nizko. Iny tip: 90
Prilis vysoko. Iny tip: 80
Spravne!

Príkazy break a continue

V C/C++ existuje dvojica príkazov umožňujúcich umelo prerušiť vykonávanie cyklu resp. jednej jeho iterácie:

• Príkaz break ukončí cyklus, v ktorom sa program práve nachádza; vykonávanie programu pokračuje prvým príkazom za cyklom.
• Príkaz continue „skočí” na ďalšiu iteráciu cyklu, pričom nevykoná zvyšok tela cyklu.

Tieto príkazy treba používať s mierou, keďže robia program menej prehľadným a sú častým zdrojom chýb.

Príklad: Hra „hádaj číslo” po druhé

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ď používateľ uhádne.

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

int main(void) {
    srand(time(NULL));

    int num = rand() % 100 + 1;
    cout << "Myslim si cislo od 1 po 100. Tvoj tip: ";
    
    while (true) {
        int guess;
        cin >> guess;
        if (guess < num) {
            cout << "Prilis nizko. Iny tip: ";
        } else if (guess > num) {
            cout << "Prilis vysoko. Iny tip: ";        
        } else {
            cout << "Spravne!" << endl;
            break;
        }
    }
    return 0;
}

Viac o cykle for

Schéma cyklu for

Cyklus for sme doposiaľ používali iba veľmi základným spôsobom; jeho možnosti sú omnoho väčšia. Vo všeobecnosti možno schému cyklu for popísať nasledovne:

for (prikaz1; podmienka; prikaz2) {
    postupnost_prikazov
}

Takýto cyklus potom pracuje nasledovne:

• Vykoná sa príkaz prikaz1.
• Kým platí podmienka podmienka, vykonáva sa telo cyklu postupnost_prikazov zakaždým nasledované príkazom prikaz2.

Uvedený cyklus for je teda typicky ekvivalentný nasledujúcemu cyklu while:

prikaz1;
while (podmienka) {
    postupnost_prikazov
    prikaz2;
}

(Drobnou nepodstatnou výnimkou z uvedeného tvrdenia je prípad, keď telo cyklu for obsahuje príkaz continue. V takom prípade sa príkaz prikaz2 aj tak vykoná.)

Nasledujúce kúsky kódu napríklad obidva vypisujú čísla 0 až 9:

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

int i = 0;
while (i <= 9) {
    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.

Príklad č. 1: Vypisovanie deliteľov po druhé

Vráťme sa k programu na vypisovanie všetkých deliteľov čísla n z úvodu tejto prednášky. Tam sme deliteľov vypisovali v poradí od najmenšieho po najväčší, a to použitím cyklu

for (int i = 1; i <= n; i++)

Nahradením tohto cyklu cyklom

for (int i = n; i > 0; i--)

získame program vypisujúci delitele v poradí od najväčšieho po najmenší.

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Zadajte cislo: ";
    cin >> n;
    
    cout << "Delitele cisla " << n << ":";
    for (int i = n; i > 0; i--) {
        if (n % i == 0) {
            cout << " " << i;
        }
    }
    cout << endl;
    return 0;
}

Príklad behu programu:

Zadajte cislo: 30
Delitelia cisla 30: 30 15 10 6 5 3 2 1

Príklad č. 2: Vypisovanie deliteľov po tretie

Program na vypisovanie deliteľov môžeme o niečo urýchliť: stačí si všimnúť, že i je deliteľ čísla n práve vtedy, keď je deliteľom čísla n číslo n/i; číslo n/i teda môžeme rovno vypísať spoločne s i. Aspoň jedno z tejto dvojice čísel je navyše menšie alebo rovné odmocnine z n, čo znamená, že stačí prehľadať iba čísla i spĺňajúce túto podmienku.

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cout << "Zadajte cislo: ";
    cin >> n;
    
    cout << "Delitelia cisla " << n << ":";
    for (int i = 1; i*i <= n; i++) {
        if (n % i == 0) {
            cout << " " << i << " " << n / i;
        }
    }
    cout << endl;
    return 0;
}

Cvičenie 1: Občas sa môže stať, že program vypíše niektorého deliteľa dvakrát. Kedy? Modifikujte telo cyklu for tak, aby program každého deliteľa vypísal práve raz.

Cvičenie 2: Vyskúšajte si rýchlosť rôznych variantov programu na vypisovanie deliteľov na veľkom vstupe, napríklad pre n = 1234567890.

Príklad č. 3: Nekonečný cyklus for

V cykle

for (prikaz1; podmienka; prikaz2) {
    postupnost_prikazov
}

môžu byť príkazy prikaz1 a prikaz2 aj prázdne – v takom prípade sa na ich mieste nič nevykoná. Podobne môže byť prázdna aj podmienka podmienka, ktorá sa v takom prípade interpretuje ako true. Z uvedeného vyplýva, že nekonečný cyklus možno napísať aj ako

for ( ; true; ) {
    cout << "Hello, World!" << endl;
}

prípadne ekvivalentne ako

for ( ; ; ) {
    cout << "Hello, World!" << endl;
}

Vnorené cykly

Vykreslíme „štvorec” pozostávajúci z n krát n čísel, ktoré sú striedavo 0 a 1, podobne ako biele a čierne políčka na šachovnici.

• Potrebujeme na to dva vnorené cykly: jeden pôjde cez riadky, druhý cez stĺpce.
• Ak je hodnota row + column párna, píšeme 0; inak píšeme 1.

#include <iostream>
using namespace std;

int main(void) {
    int n;
    cin >> n;
    for (int row = 0; row <= n - 1; row++) {
        for (int column = 0; column <= n - 1; column++) {
            if ((row + column) % 2 == 0) {
                cout << "0";
            } else {
                cout << "1";
            }
        }
        cout << endl;
    }
    
    return 0;
}

Úprava a čitateľnosť programov

Pri písaní programov je potrebné myslieť na to, že ho typicky budú okrem počítača čítať aj ľudia (či už ide o vás samotných po dlhšom čase, učiteľov, alebo v praxi o spolupracovníkov na väčšom projekte). Je preto zvykom dodržiavať určité zásady, ktoré čitateľnosť zdrojového kódu zlepšujú:

• Odsadzovanie: príkazy vykonávané v cykle, či v podmienke (alebo vo všeobecnosti v ľubovoľnom bloku medzi { a }) kvôli čitateľnosti odsadzujeme o niekoľko pozícií doprava (napríklad o 4 medzery). Pri vnorených cykloch, podmienkach a podobne odsadzujeme o ďalšie štyri pozície, atď. Väčšina syntax zvýrazňujúcich textových editorov a IDE pre C/C++ nejakým spôsobom odsadzovanie podporujú (minimálne by sa mala dať nastaviť šírka tabulátora).
• Voľné riadky: ucelené časti programu je kvôli prehľadnosti často dobré oddeliť prázdnym riadkom.
• Medzery: odporúča sa (najmä v zložitejších výrazoch) písať okolo operátorov medzery.
• Napríklad zápis

for (int i = 0; i <= count - 1; i++) {
    a += i;
}

je o dosť prehľadnejší ako

for(int i=0;i<=count-1;i++){a+=i;}

• Dĺžka riadku: odporúča sa vyhýbať sa riadkom dlhším ako 80 znakov (aj keď nie vždy sa tento limit dá dodržať striktne). S dlhými riadkami sú problémy pri tlači alebo zobrazovaní v menších oknách; aj na veľkom monitore čitateľa zbytočne namáhajú. V prípade potreby je možné dlhšiu podmienku alebo iný výraz rozdeliť na viac riadkov.
• Názvy premenných: najmä pri rozsiahlejších programoch je vhodné používať názvy premenných, ktoré vyjadrujú ich obsah (napríklad userCount alebo pocet_pouzivatelov namiesto h). Premenné v kratších programoch, alebo premenné používané iba lokálne v kratšom kuse programu možno označovať aj krátkymi zaužívanými názvami, ako napríklad i a j pre premenné v cykloch, n pre počet, alebo a pre pole.
• Komentáre: význam jednotlivých úsekov kódu je najmä pri rozsiahlejších programoch dobré popísať v komentároch.

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

Cykly: zhrnutie

• Videli sme niekoľko príkladov využitia cyklov for a while.
• Cyklus for je možné zapísať ako while (a naopak).
• 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.

Prednáška 4

Oznamy

• V pondelok 7. októbra bude v čase prednášky teoretické cvičenie, na ktorom sa bude (na papier) písať krátky test zameraný na praktické znalosti učiva preberaného na prvých troch prednáškach. Za tento test sa budú udeľovať body v rámci hodnotenia cvičení č. 2 (úspešní riešitelia testu pre pokročilých sa teda testu zúčastniť nemusia). Na teste bude povolené používať ťahák vo forme jedného obojstranne popísaného listu A4, žiadne ďalšie pomôcky však povolené nebudú.

Funkcie

Funkcia je samostatný kus kódu (postupnosť príkazov) s určitým menom. (V iných programovacích jazykoch sa možno stretnúť aj s príbuznými termínmi ako procedúra, metóda, či podprogram.) Po zavolaní funkcie jej menom sa daná postupnosť príkazov vykoná.

• Funkcia vo všeobecnosti berie niekoľko (aj nula) vstupných argumentov ľubovoľného typu, ktoré môže pri svojom behu používať.
• Funkcia tiež vo všeobecnosti vracia výstupnú hodnotu nejakého typu (tento typ ale môže byť void; v takom prípade vlastne funkcia nevracia žiadnu hodnotu).
• Ide teda o veľmi podobný koncept ako funkcie v matematike: oboje si možno predstaviť ako „krabičku”, ktorá na základe niekoľkých vstupných hodnôt vráti nejakú výstupnú hodnotu. Drobným rozdielom ale je, že funkcie v C/C++ sa môžu okrem vracania výstupných hodnôt prejavovať aj inak: môžu vykonávať ľubovoľný kód, teda napríklad aj niečo vypisovať na konzolu a podobne.

Funkcie sú užitočné z viacerých dôvodov:

• Umožňujú vytvoriť „skratku” pre často používané (nezriedka aj rozsiahle) časti kódu, ktoré tak nie je nutné zakaždým písať nanovo.
• Umožňujú používanie kusov kódu vytvorených iným programátorom. Napríklad sme sa už stretli s funkciou sqrt, ktorá vráti druhú odmocninu svojho vstupu.
• Logicky napísané funkcie umožňujú oddeliť očakávanú funkcionalitu od jej reálnej implementácie. Napríklad pri volaní sqrt nás implementácia tejto funkcie typicky nemusí zaujímať – stačí vedieť, že pre každé číslo na vstupe táto funkcia vráti jeho odmocninu.

Špeciálnym prípadom funkcie je aj nám už známa funkcia main; viac si o jej špecifikách povieme na konci tejto prednášky.

Motivačný príklad č. 1: Obvod trojuholníka bez použitia funkcií

Užitočnosť funkcií si najlepšie vysvetlíme na príklade. Predpokladajme, že chceme napísať program, ktorý od používateľa načíta súradnice vrcholov trojuholníka ABC a následne na výstup vypíše obvod tohto trojuholníka. Beh takéhoto programu teda môže vyzerať napríklad takto:

Zadaj suradnice vrcholu A: 0 0
Zadaj suradnice vrcholu B: 3 0
Zadaj suradnice vrcholu C: 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.

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

int main(void) {
    double Ax, Ay, Bx, By, Cx, Cy;
    
    cout << "Zadaj suradnice vrcholu A: "; 
    cin >> Ax >> Ay;
    cout << "Zadaj suradnice vrcholu B: ";
    cin >> Bx >> By;
    cout << "Zadaj suradnice vrcholu C: ";
    cin >> Cx >> Cy;
    
    /* Spocitaj dlzky jednotlivych stran: */
    double a = sqrt((Bx - Cx) * (Bx - Cx) + (By - Cy) * (By - Cy));
    double b = sqrt((Ax - Cx) * (Ax - Cx) + (Ay - Cy) * (Ay - Cy));
    double c = sqrt((Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By));
    
    cout << "Obvod trojuholnika ABC: " << a + b + c;
    
    return 0;
}

Opakované písanie toho istého vzorca na výpočet dĺžky strany je pomerne prácne; navyše pri ňom ľahko spravíme chybu. V nasledujúcom sa ho preto pokúsime nahradiť funkciou.

Motivačný príklad č. 2: Obvod trojuholníka s použitím funkcie

Videli sme teda, že na výpočet obvodu trojuholníka sa nám môže zísť funkcia počítajúca vzdialenosť medzi dvoma bodmi v rovine (dĺžka jednej strany trojuholníka je totiž vzdialenosťou jeho koncových bodov). Tá môže v C/C++ vyzerať napríklad takto:

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

Týmto sme zadefinovali funkciu s názvom dist so štyrmi vstupnými argumentmi x1,y1,x2,y2 typu double, reprezentujúcimi súradnice dvojice bodov v rovine. Pred samotný názov funkcie sme zadali návratový typ funkcie, ktorým je double – táto funkcia teda bude vracať na výstupe reálne čísla. Nakoniec sme zadefinovali samotné telo funkcie, tentokrát pozostávajúce z jediného špeciálneho príkazu return, ktorým funkcia vracia svoju výstupnú hodnotu.

Kompletný program na výpočet obvodu trojuholníka môže s použitím funkcie dist vyzerať napríklad takto:

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

/* Definicia funkcie dist: */
double dist(double x1, double y1, double x2, double y2) {
    return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
}

int main(void) {
    double Ax, Ay, Bx, By, Cx, Cy;
    
    cout << "Zadaj suradnice vrcholu A: "; 
    cin >> Ax >> Ay;
    cout << "Zadaj suradnice vrcholu B: ";
    cin >> Bx >> By;
    cout << "Zadaj suradnice vrcholu C: ";
    cin >> Cx >> Cy;
    
    /* Spocitaj dlzky jednotlivych stran: */
    double a = dist(Bx, By, Cx, Cy); // Volanie funkcie dist s argumentmi Bx, By, Cx, Cy.
    double b = dist(Ax, Ay, Cx, Cy); // Volanie funkcie dist s argumentmi Ax, Ay, Cx, Cy.
    double c = dist(Ax, Ay, Bx, By); // Volanie funkcie dist s argumentmi Ax, Ay, Bx, By.
    
    cout << "Obvod trojuholnika ABC: " << a + b + c;
    
    return 0;
}

Telo funkcie nemusí pozostávať iba z jediného príkazu, ale môže ísť o plnohodnotný kus programu. Napríklad ešte jednoduchšie by sme funkciu dist mohli napísať takto:

double dist(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 existuje funkcia sqr, ktorá na vstupe berie reálne číslo x a výstupom je toto číslo umocnené na druhú. Naprogramujte túto funkciu v C/C++ a použite ju na zjednodušenie funkcie dist.
• Mohli by sme použiť aj pow(x,2) (treba #include <cmath>), ničmenej môže byť jednoduchšie zrátať x*x.

Definícia funkcie

Definícia funkcie vo všeobecnosti pozostáva z nasledujúcich častí:

• Typ návratovovej hodnoty funkcie. Funkcia z úvodného príkladu napríklad vracia vzdialenosť bodov v rovine, teda hodnotu typu double. Podobne môžeme písať funkcie vracajúce iné návratové typy, ako napríklad int. Funkcie, ktoré nemajú vracať žiadnu návratovú hodnotu majú špeciálny návratový typ void – ide typicky o funkcie, ktoré len vykonajú určitú činnosť, napríklad vypísanie textu na konzolu a podobne.
• Identifikátor funkcie. Funkciu môžeme (v rámci určitých medzí) pomenovať prakticky ľubovoľne, rovnako ako pri premenných. Vhodné je však použiť názov, ktorý vystihuje úlohu danej funkcie (napríklad dist od angl. distance).
• Zoznam vstupných parametrov funkcie. V zátvorkách za názvom funkcie je zoznam typov a identifikátorov vstupných argumentov, ktoré funkcia očakáva. V úvodnom príklade funkcia očakáva súradnice dvoch bodov v rovine, teda štyri hodnoty typu double. Ak funkcia neočakáva žiaden vstupný argument, môžeme do zátvoriek napísať void, prípadne nechať zoznam argumentov prázdny (rozdiel je minimálny, ale odporúčaná je prvá možnosť).
• Telo funkcie. Do zložených zátvoriek za definíciou funkcie píšeme jej vlastný obsah – teda postupnosť príkazov, ktoré má funkcia vykonať.
• Príkaz return. Vracia návratovú hodnotu funkcie.

typ_navratovej_hodnoty identifikator_funkcie(zoznam_vstupnych_argumentov) {
    telo_funkcie // Môže obsahovať príkazy return.
}

Príklad č. 1: Súčet čísel od a po b

Nasledujúca funkcia dostane na vstupe dvojicu celých čísel a, b a na výstupe vráti súčet všetkých celých čísel od a po b, t.j. hodnotu

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 + (a + 1) + \ldots + (b - 1) + b = \sum_{i = a}^b i.}

/* Funkcia, ktora spocita sucet a + (a+1) + ... + (b-1) + b */
int sum(int a, int b) {
    int result = 0;
    for (int i = a; i <= b; i++) {
        result += i;
    }    
    return result;
}

Kompletný program využívajúci túto funkciu môže vyzerať napríklad takto:

#include <iostream>
using namespace std;

/* Funkcia, ktora spocita sucet a + (a+1) + ... + (b-1) + b */
int sum(int a, int b) {
    int result = 0;
    for (int i = a; i <= b; i++) {
        result += i;
    }    
    return result;
}

int main(void) {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    cout << "Sucet celych cisel od " << a << " po " << b << ": ";
    cout << sum(a, b) << endl;

    return 0;
}

Príklad č. 2: Vypisovanie čísel od a po b

Predpokladajme teraz, že potrebujeme napísať funkciu printNumbers, ktorá čísla od a po b iba vypíše na výstup. Takáto funkcia teda nebude vracať žiadnu zmysluplnú hodnotu – jej návratový typ bude void. V ostatnom sa táto funkcia od funkcie z predošlého príkladu nebude príliš odlišovať.

/* Funkcia, ktora vypise cisla a, (a+1), ..., (b-1), b */
void printNumbers(int a, int b) {
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        cout << " " << i;
    }    
    cout << endl;
}

Kompletný program využívajúci túto funkciu:

#include <iostream>
using namespace std;

/* Funkcia, ktora vypise cisla a, (a+1), ..., (b-1), b */
void printNumbers(int a, int b) {
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        cout << " " << i;
    }    
    cout << endl;
}

int main(void) {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    printNumbers(a, b);

    return 0;
}

Príklad č. 3: Sčítanie a súčasné vypisovanie čísel a od b

Funkcie z predchádzajúcich dvoch príkladov je možné spojiť do jednej, ktorá tieto čísla vypíše a súčasne na výstupe vráti ich súčet:

/* Funkcia, ktora scita a vypise cisla a, (a+1), ..., (b-1), b */
int sumAndPrint(int a, int b) {
    int result = 0;
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        result += i;
        cout << " " << i;
    }    
    cout << endl;
    return result;
}

Kompletný program využívajúci túto funkciu:

#include <iostream>
using namespace std;

/* Funkcia, ktora scita a vypise cisla a, (a+1), ..., (b-1), b */
int sumAndPrint(int a, int b) {
    int result = 0;
    cout << "Cisla od " << a << " po " << b << ":";    
    for (int i = a; i <= b; i++) {
        result += i;
        cout << " " << i;
    }    
    cout << endl;
    return result;
}

int main(void) {
    int a, b;
    
    cout << "Zadaj dvojicu celych cisel: ";
    cin >> a >> b;
    
    int sum = sumAndPrint(a, b);
    cout << "Sucet cisel je: " << sum << endl;
    
    sumAndPrint(a,b); // Vystupnu hodnotu funkcie mozeme aj odignorovat.

    return 0;
}

Príklad č. 4: Fibonacciho čísla

Fibonacciho postupnosť je postupnosť čísel taká, že:

• Nultý člen je 0.
• Prvý člen je 1.
• Každý ďalší člen postupnosti je daný súčtom dvoch predchádzajúcich.

Jednotlivé členy tejto postupnosti sa nazývajú Fibonacciho čísla. Prvých niekoľko členov Fibonacciho postupnosti 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 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, \ldots}

a n-té Fibonacciho číslo F(n) možno vypočítať pomocou nasledujúceho rekurentného vzťahu:

• F(0) = 0,
• F(1) = 1,
• Pre všetky prirodzené čísla n ≥ 2: F(n) = F(n - 1) + F(n - 2).

Napíšeme teraz funkciu fibonacci, ktorá pre dané n vypočíta n-té Fibonnaciho číslo.

int fibonacci(int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        int F_posledne = 1;
        int F_predposledne = 0;
        for (int i = 2; i <= n; i++) {
            int F_n = F_posledne + F_predposledne;
            F_predposledne = F_posledne;
            F_posledne = F_n;                     
        }
        return F_posledne;
    }
}

Kompletný program využívajúci túto funkciu:

#include <iostream>
using namespace std;

int fibonacci(int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        int F_posledne = 1;
        int F_predposledne = 0;
        for (int i = 2; i <= n; i++) {
            int F_n = F_posledne + F_predposledne;
            F_predposledne = F_posledne;
            F_posledne = F_n;                     
        }
        return F_posledne;
    }
}

int main(void) {
    int n;
    cout << "Zadaj n: ";
    cin >> n;
    
    cout << "F(" << n << ") = " << fibonacci(n) << endl;

    return 0;
}

Príklad behu programu:

Zadaj n: 9
F(9) = 34

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

• Akú bude mať táto funkcia hlavičku?
• Vyskúšajte dva spôsoby implementácie: volaním funkcie fibonacci pre rôzne hodnoty n a prepísaním tejto funkcie, aby sa hodnoty vypisovali priamo počas ich výpočtu. Ktorý spôsob bude rýchlejší pre veľké n a prečo?

Príkaz return

Pozrime sa teraz bližšie na špeciálny príkaz return:

• Po vykonaní príkazu return je funkcia okamžite zastavená a jej výstupná hodnota je výraz za slovom return.
• Funkcia môže obsahovať aj viacero volaní return. Akonáhle sa však jedno z nich vykoná, funkcia končí s danou návratovou hodnotou. Napríklad:

#include <iostream>
using namespace std;

int f(void) {
    return 1;
    return 2; // Nikdy sa nevykona.
    return 3; // Nikdy sa nevykona.
}

int main(void) {
    cout << f() << endl; // Vypise 1.
    return 0;
}

• Funkcia s návratovým typom void môže tiež obsahovať príkaz return, avšak bez návratovej hodnoty za ním (t.j. bezprostredne nasledovaný bodkočiarkou). V takom prípade slúži iba na ukončenie vykonávania funkcie podobne, ako v nasledujúcom príklade, ktorý je ukážkou vyslovene zlého programátorského štýlu:

#include <iostream>
using namespace std;

void f(int n) {
    if (n >= 0) {
        cout << "Cislo je nezaporne." << endl;
        return;
    }
    cout << "Cislo je zaporne." << endl; // Vykona sa len v pripade n < 0.
}

int main(void) {
    int n;
    cin >> n;
    f(n);
    return 0;
}

• Napríklad minimum z dvoch čísel môžeme vypočítať dvoma rôznymi spôsobmi (ak z nejakého dôvodu nechceme použiť niektorú zo štandardných funkcií slúžiacich k tomuto účelu):

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

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

• Funkcie s návratovým typom iným ako void je žiadúce písať tak, aby na ľubovoľnom vstupe ich vykonávanie vždy skončilo príkazom return. Ak totiž takáto funkcia skončí inak, než príkazom return, jej výstupná hodnota je nedefinovaná (použije sa „hocijaký nezmysel”). Neskoršie volanie takýchto funkcií potom môže viesť k zákerným chybám. Definíciu funkcie s typom iným ako void, ktorá môže skončiť inak ako príkazom return, teda budeme považovať za chybu (a to aj v prípade „istoty”, že sa výstupné hodnoty tejto funkcie nebudú nikde používať; vtedy je totiž správnou voľbou návratový typ void).

Cvičenie: Nájdite hodnotu nasledujúcej funkcie pre n=6 a n=7. Viete stručne popísať, čo funkcia 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é

Premenné v C/C++ možno rozdeliť na globálne a lokálne:

• Globálne premenné možno používať vo všetkých funkciách, ktoré sú v programe definované za touto premennou.
• Lokálne premenné sú definované vo vnútri funkcie a môžu sa používať iba v rámci nej (alebo iba v rámci niektorej časti tejto funkcie, ak je táto premenná definovaná napríklad v tele cyklu a podobne).

Platí navyše, že:

• Viaceré funkcie môžu mať lokálne premenné s tým istým názvom – každá funkcia potom samozrejme používa tú svoju.
• Ak má lokálna premenná rovnaký názov ako nejaká globálna premenná, lokálna premenná prekryje globálnu – funkcia teda používa svoju lokálnu premennú (bližšia košeľa ako kabát).

Je silno odporúčané používať predovšetkým lokálne premenné. Väčšie programy s globálnymi premennými môžu byť veľmi neprehľadné.

Príklad č. 1: Program s globálnou premennou x

Nasledujúci program obsahuje globálnu premennú x a v každej funkcii lokálnu premennú s názvom y:

#include <iostream>
using namespace std;

int x;

void f(void) {
    int y = 10;
    cout << x << " " << y << endl;      
}

int main(void) {
    x = 10;
    int y = 20;
        
    f();                            // Vypise 10 10.  
    cout << x << " " << y << endl;  // Vypise 10 20.
    
    return 0;
}

Príklad č. 2: Prekrývanie globálnych premenných lokálnymi

Nasledujúci program demonštruje mechanizmus prekrývania globálnych premenných lokálnymi.

#include <iostream>
using namespace std;

/* Z nasledujucej funkcie globalnu premennu n pouzivat nemozeme, lebo je 
 * v programe definovana az neskor: */
void f1(void) {
    // n = 1; 
}

int n = -1;    // Premennu n inicializujeme na hodnotu -1.

void f2(void) {
    n = 2;     // Nastavi hodnotu globalnej premennej n na 2.
}

void f3(void) {
    int n;     // Lokalna premenna prekryje globalnu. 
    n = 3;     // Meni len lokalnu premennu bez vplyvu na globalnu premennu n.
}

int main(void) {
    cout << n << endl; // Vypise -1.
    f2();      
    cout << n << endl; // Vypise 2.
    f3();      
    cout << n << endl; // Vypise 2.
    
    return 0;
}

Parametre funkcií

Odovzdávanie parametrov hodnotou

Vstupné parametre funkcií sa správajú ako lokálne premenné danej funkcie. Pri volaní funkcie sa každému parametru priradí určitá hodnota. Uvažujme napríklad funkciu

void f(int a, int b) {
    // ...
}

Pri volaní

f(1,2);

sa parametru a priradí hodnota 1 a parametru b sa priradí hodnota 2. Tieto sa ďalej správajú ako lokálne premenné funkcie f. Možno ich teda meniť, ale táto zmena sa neprejaví na mieste, odkiaľ funkciu voláme. Tento mechanizmus nazývame odovzdávaním parametrov hodnotou.

Príklad:

#include <iostream>
using namespace std;

void f(int n) {
    n++;
    cout << n << endl;
}

int main(void) {
    int n = 1;
    f(n);               // Vypise 2.
    cout << n << endl;  // Vypise 1.
    
    return 0;
}

Odovzdávanie parametrov referenciou

V prípade, že pred názov niektorého parametra v hlavičke funkcie napíšeme &, parameter sa bude odovzdávať referenciou.

• Za takýto parameter možno pri volaní funkcie dosadiť iba premennú (kým pri odovzdávaní hodnotou môžeme použiť napríklad aj konštanty alebo iný výraz).
• Namiesto samotnej hodnoty sa funkcii pošle adresa premennej v pamäti (referencia).
• Funkcia potom bude túto premennú používať pod novým názvom; jej prípadné zmeny sa prejavia aj na mieste, odkiaľ bola funkcia volaná.

Príklad:

#include <iostream>
using namespace std;

void f(int &n) {
    n++;
    cout << n << endl;
}

int main(void) {
    int n = 1;
    f(n);               // Vypise 2.
    cout << n << endl;  // Vypise 2.
    
    return 0;
}

Príklad č. 1: Viac ako jedna návratová hodnota

Odovzdávanie parametra referenciou používame napríklad vtedy, keď potrebujeme vrátiť viac ako jednu výstupnú hodnotu. Napríklad nasledujúca funkcia mid dostane súradnice dvoch bodov [x1,y1] a [x2,y2] a do parametrov [xm,ym], ktoré sú odovzdané referenciou, uloží súradnice stredu úsečky spájajúcej body [x1,y1] a [x2,y2].

#include <iostream>
using namespace std;

void mid(double x1, double y1, double x2, double y2, double &xm, double &ym) {
    xm = (x1 + x2) / 2;
    ym = (y1 + y2) / 2;
}

int main(void) {
    double Ax, Ay, Bx, By;
    
    cout << "Zadaj suradnice bodu A: ";
    cin >> Ax >> Ay;
    cout << "Zadaj suradnice bodu B: ";
    cin >> Bx >> By;
    
    double Mx, My;
    mid(Ax, Ay, Bx, By, Mx, My);
    cout << "Stred usecky AB je [" << Mx << ", " << My << "]." << endl; 
        
    return 0;
}

Príklad č. 2: Funkcia swap

Typickým príkladom na použitie odovzdávania referenciou 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(void) {
    int x, y;
    cin >> x >> y;
    
    swap(x, y);
    
    cout << "x = " << x << ", y = " << y << endl; 
        
    return 0;
}

Keby sme funkcii odovzdali parameter hodnotou – čiže by sme funkciu swap definovali s hlavičkou void swap(int a, int b); – vo funkcii main by sa premenné nevymenili.

Ošetrovanie chybných vstupov

Občas môže nastať potreba, aby parametre funkcie spĺňali určité podmienky. V takom prípade je potrebné korektne sa vysporiadať aj so vstupmi, ktoré tieto podmienky nespĺňajú (aj keď túto skutočnosť budeme často zámerne ignorovať). Ukážeme si teraz zopár možných prístupov k tomuto problému.

Funkcia neošetrujúca chybné vstupy

Uvažujme napríklad nasledujúcu funkciu, ktorá počíta súčet všetkých deliteľov čísla n. Jej základným predpokladom je, že n je kladné celé číslo.

#include <iostream>
using namespace std;

int sumOfDivisors(int n) {
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            sum += i;    
        }        
    }   
    return sum;  
}

int main(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

Ak však používateľ zadá na vstupe nejaké záporné číslo, funkcia vždy vráti nulu, čo nie je úplne v súlade s očakávaním. Jednou možnosťou by samozrejme bolo prerobiť funkciu tak, aby pracovala správne aj na záporných vstupoch. Sú však aj situácie, keď podobné riešenie nie je možné. Ukážeme si preto ďalšie spôsoby, ako sa s nekorektným vstupom vysporiadať.

Použitie funkcie exit

V prípade použitia nekorektného vstupu napríklad môžeme celý program ihneď ukončiť funkciou exit (treba #include <cstdlib>). Parametrom tejto funkcie je návratová hodnota celého programu, ktorá typicky udáva, či program skončil korektne alebo nie. V našom prípade zrejme potrebujeme vyjadriť neúspešné ukončenie programu – ako parameter funkcie exit teda použijeme konštantu EXIT_FAILURE.

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

int sumOfDivisors(int n) {
    if (n <= 0) {
        exit(EXIT_FAILURE);    
    }
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            sum += i;    
        }        
    }   
    return sum;  
}

int main(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

Použitie funkcie assert

Pohodlnejšou alternatívou je použitie funkcie assert (treba #include <cassert>). Táto funkcia umožňuje predpokladať platnosť nejakej podmienky – ak je táto podmienka splnená, program normálne pokračuje; v opačnom prípade sa program zastaví s chybovou hláškou. Argumentom funkcie assert môže byť ľubovoľná booleovská hodnota.

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

int sumOfDivisors(int n) {
    assert(n > 0);
    int sum = 0;
    for (int i = 1; i <= n; i++) {
        if (n % i == 0) {
            sum += i;    
        }        
    }   
    return sum;  
}

int main(void) {
    int n;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
        
    cout << "Sucet delitelov " << n << ": " << sumOfDivisors(n) << "." << endl;
        
    return 0;
}

Úspech výpočtu ako výstupná hodnota

Často je ale neprípustné v prípade jediného volania funkcie s nekorektnými vstupmi ukončiť celý program. Elegantnejším riešením je preto napríklad nasledovné: súčet deliteľov už nebudeme vracať ako výstupnú hodnotu, ale budeme ho ukladať do parametra odovzdávaného referenciou. Výstupom funkcie bude namiesto toho booleovská hodnota, ktorá bude true práve vtedy, keď výpočet funkcie prebehol správne (t.j. keď boli zadané správne argumenty). Túto výstupnú hodnotu je potom možné použiť pri volaní funkcie ako známku toho, že hodnota v parametre predanom referenciou je zmysluplná.

#include <iostream>
using namespace std;

bool sumOfDivisors(int n, int &sum) {
    if (n <= 0) {
        return false;
    } else {
        sum = 0;
        for (int i = 1; i <= n; i++) {
            if (n % i == 0) {
                sum += i;    
            }        
        }   
        return true;
    }  
}

int main(void) {
    int n, sum;
    cout << "Zadaj kladne cele cislo: ";
    cin >> n;
    
    if (sumOfDivisors(n, sum)) { 
        cout << "Sucet delitelov " << n << ": " << sum << "." << endl;
    } else {
        cout << "Zly vstup" << endl;
    }
        
    return 0;
}

Programy s viacerými funkciami

V programe možno volať iba funkcie, ktoré už predtým boli niekde definované alebo aspoň deklarované (tento pojem si ozrejmíme o chvíľu). Napríklad

void f1(void) {
    f2();
}

void f2(void) {
    cout << "Hello, World!" << endl;
}

typicky neskompiluje, kým

void f2(void) {
    cout << "Hello, World!" << endl;
}

void f1(void) {
    f2();
}

je v poriadku. Program tiež skompiluje v prípade, že každú funkciu pred jej volaním aspoň zadeklarujeme – t.j. uvedieme jej hlavičku bez definície jej tela – a samotnú definíciu funkcie uvedieme až neskôr. V poriadku je teda napríklad aj nasledujúci program:

void f2(void);

void f1(void) {
    f2();
}

void f2(void) {
    cout << "Hello, World!" << endl;
}

Funkcia main

Špeciálnou funkciou je v C/C++ funkcia main. Od ostatných funkcií sa odlišuje v nasledujúcom:

• V programe ju nemožno volať – jediné jej volanie je automatické (začína sa ním beh programu).
• Výstupná hodnota funkcie main sa interpretuje ako „spôsob ukončenia” programu (napríklad 0 pre korektné ukončenie, iné hodnoty pre chyby).
• Funkcia main môže mať aj určité presne špecifikované parametre (viac o tom neskôr).

Funkcie: 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é sa zadajú pri volaní funkcie.
• Parametre odovzdávané referenciou (&) sú len novým menom pre inú premennú.

Teoretické cvičenie

Čo nás čaká v najbližšom čase

• Dnes teoretické cvičenie
• Zajtra cvičenia, rozcvička bude na funkcie, môže byť dobrý nápad pozrieť si poznámky z minulej prednášky
• V stredu prednáška, začneme preberať polia
• Koncom týždňa sa objaví zadanie prvej DǓ, čas cca 2 týždne

Ciele dnešného cvičenia

• Precvičiť si poriadnejšie základné konštrukty
• Vynechaním jednej prednášky vznikne väčší priestor precvičiť si základy
• Vyskúšať si prácu na papieri (bude treba na aj písomkách)

Prečo robíme toto cvičenie a písomné testy na papieri?

• Dobré na precvičenie porozumenia hotovým programom (treba na ďalších predmetoch aj pri štúdiu odbornej literatúry)
• Núti vás dobre si premyslieť každý detail, nie len náhodne skúšať meniť rôzne časti programu, kým nezačne fungovať
• Pri zložitejších programoch sa už nedá postupovať náhodne
• Na papieri miernejšie hodnotíme drobné chyby ako chýbajúca bodkočiarka, to vám na počítači pomôže nájsť kompilátor. Dôležitejšie je sa rozhodnúť, či má byť niekde napríklad i<n alebo i<=n.

Priebeh dnešného cvičenia

• Rozdám zadania, riešite do 11:00, potom vzorové riešenia
• Kto skončí skôr a nechce vidieť vzorové riešenia, môže odísť, inak zostaňte potichu sedieť
• Neopisujte, hlavným cieľom je precvičiť si učivo, váha v záverečnom hodnotení cca 2-2,5%
• Všetky príklady sú za rovnako bodov, jeden je bonusový
• Môžete používať ťahák 1 list A4
• Píšte rovno do zadaní, nezabudnite uviesť meno. Ak potrebujete viac miesta, použite zadnú stranu
• V prvých dvoch príkladoch je prvá podúloha vyriešená, aby ste správne pochopili zadanie
• Ak zadania nie sú jasné, pýtajte sa

Prednáška 5

Oznamy

• DÚ1 bude zverejnená pravdepodobne dnes večer
• Príďte na doplnkové cvičenia, ak sa vám včera nepodarilo vyriešiť veľa príkladov. Pomôžeme vám s ďalšími príkladmi na tento týždeň
• Dnes polia, budúci pondelok hlavne ďalšie príklady a algoritmy s použitím tých častí Cčka, ktoré už poznáte
• Body z cvičení, domácich úloh a písomiek budete vidieť na testovači
  • Momentálne body z cvičení 1, teoretického cvičenia a písomky pre pokročilých

Budúcu stredu prvý test o 18:10 v posluchárni A

• Pokrýva učivo z prednášok 1-4, resp. cvičení 1 až 3 (cin, cout, premenné, výrazy, podmienky, cykly, funkcie).
• Prineste si ISIC, perá a ťahák v rozsahu jedného listu (dvoch strán) A4.
• Typy príkladov:
  • napíšte krátky program alebo funkciu (podobne ako na cvičeniach, ale na papieri)
  • zistite, čo program vypíše pre určitý vstup
  • doplňte chýbajúce časti programu alebo v ňom nájdite chyby
• Test tvorí cca 8% známky, z troch testov potrebujete spolu aspoň polovicu bodov
• Ak nemôžete prísť zo závažných príčin, treba sa čím skôr ospravedlniť

Poznámky k štúdiu

• Poriadne si skontrolujte, či máte v AIS a v indexe to isté a či sú to tie predmety, ktoré chcete brať.
  • Prípadné problémy riešte na študijnom
• Do štvrtka 10.10. je potrebné si prípadné zmeny v zápise dať potvrdiť na študijnom. Pred koncom tejto doby bývajú na študijnom dlhé rady, choďte čím skôr. Úradné hodiny mimoriadne aj 13:00-15:00.
• Informácia na stránke fakulty: [1]

K pondelňajšiemu cvičeniu

Pozor, nasledujúce výrazy skompilujú, ale asi nerobia to, čo by sme chceli:

• x != y != z
• (x && y) >= 0
• x, y >= 0 (pozri operátor ,)

Hľadanie chýb v programe

• Väčšina programov nefunguje na prvý krát, hľadanie chýb patrí medzi základné činnosti programátora
• Podobné chyby sa často opakujú, tréningom sa ich naučíte nájsť rýchlejšie

Ak program ani neskompiluje

• Kompilátor vypíše číslo riadku s chybou, čo vám ju môže pomôcť nájsť
  • Občas je však chyba trochu inde, napr. niečo chýba o riadok vyššie
• Pokročilejšie postredia, ako napr. Netbeans, vám vedia ukázať polohu chyby
• Ak kompilátor vypíše veľa chýb, opravte najskôr prvú, potom skompilujte znovu, ďalšie chyby môžu byť len dôsledkom prvej
• Ak neviete nájsť chybu pri kompilácii, skúste zakomentovať nejaké časti programu pomocou /* */, aby ste zúžili priestor, kde chyba môže byť
• Aj varovania kompilátora môžu poukazovať na chybu v programe

Ak program dáva zlá výsledky, "cyklí sa" alebo "padá"

• Môžete skúsiť program znovu prečítať, či nezbadáte chybu
  • Pomáha dobrá čitateľnosť programov
• Alebo experimentami zistiť, kde sa jeho správanie prvýkrát začne odlišovať od toho, čo očakávate
• To sa dá robiť spúšťaním programu po krokoch v nástroji nazvanom debugger (nachádza sa napr. v Netbeans)
• Alternatíva k debuggeru je do programu pridať pomocné výpisy, ktoré vám prezradia, ktorá časť programu sa práve vykonáva a aké sú hodnoty dôležitých premenných
  • Po nájdení chyby treba tieto pomocné výpisy odstrániť. Pozor, aby ste tým nespravili ďalšiu chybu
• Debugger alebo výpisy vám pomôžu nájsť chybu iba vtedy, ak máte predstavu o tom, ako by program mal fungovať a hľadáte, kde sa od nej skutočné správanie líši
• Pomáha si vyrobiť čo najmenší vstup, kde je zlý výsledok

Záznam typu struct

V príkladoch s obvodom trojuholníka a stredom úsečky sme funkciám posielali veľa parametrov (súradnice x a y)

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

Program bude krajší, ak si údaje o jednom bode spojíme do jedného záznamu

struct bod {
    double x, y;
};

• Pomocou struct vytvoríme nový dátový typ bod, ktorý má zložky x a y
  • V jednom struct-e môžu byť aj položky rôznych typov (napr. struct bod { double x,y; int id; bool visible; };)
• Môžeme vytvárať premenné typu bod, napr. bod a, b;
• K položkám bodu pristupujeme pomocou bodky, napr. a.x = 4.0;
• Do funkcií body posielame radšej referenciou, aby sa zbytočne nekopírovalo veľa hodnôt

Nasledujúci program načíta súradnice troch bodov, spočíta obvod trojuholníka a stredy všetkých troch strán.

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

struct bod {
    double x, y;  // suradnice bodu v rovine
};

double dlzka(bod &bod1, bod &bod2) {
    // funkcia vrati dlzku usecky z bodu 1 do bodu 2
    double dx = bod1.x - bod2.x;
    double dy = bod1.y - bod2.y;
    return sqrt(dx * dx + dy * dy);
}

void stred(bod &bod1, bod &bod2, bod &stred) {
    // funkcia do bodu stred spocita stred usecky z bodu 1 do bodu 2
    stred.x = (bod1.x + bod2.x) / 2;
    stred.y = (bod1.y + bod2.y) / 2;
}

void vypisBod(bod &b) {
    // funkcia vypise surandice bodu v zatvorke a koniec riadku
    cout << "(" << b.x << "," << b.y << ")" << endl;
}

int main(void) {
    // nacitame suradnice vrcholov trojuholnika
    bod A, B, C;
    cout << "Zadaj suradnice vrcholu A oddelene medzerou: ";
    cin >> A.x >> A.y;
    cout << "Zadaj suradnice vrcholu B oddelene medzerou: ";
    cin >> B.x >> B.y;
    cout << "Zadaj suradnice vrcholu C oddelene medzerou: ";
    cin >> C.x >> C.y;
    // spocitame dlzky stran
    double da = dlzka(B, C);
    double db = dlzka(A, C);
    double dc = dlzka(A, B);
    // vypiseme obvod
    cout << "Obvod trojuholnika ABC: " << da + db + dc << endl;

    // spocitame stredy stran
    bod stredAB;
    stred(A, B, stredAB);
    bod stredAC;
    stred(A, C, stredAC);
    bod stredBC;
    stred(B, C, stredBC);

    // vypiseme stredy stran
    cout << "Stred strany AB: ";
    vypisBod(stredAB);
    cout << "Stred strany AC: ";
    vypisBod(stredAC);
    cout << "Stred strany BC: ";
    vypisBod(stredBC);
}

Príklad behu programu:

Zadaj suradnice vrcholu A oddelene medzerou: 0 0
Zadaj suradnice vrcholu B oddelene medzerou: 0 3
Zadaj suradnice vrcholu C oddelene medzerou: 4 0
Obvod trojuholnika ABC: 12
Stred strany AB: (0,1.5)
Stred strany AC: (2,0)
Stred strany BC: (2,1.5)

Spracovanie väčšieho množstva dát

Naše programy doteraz spracovávali len malý počet vstupných dát načítaných od užívateľa (napr. súradnice troch bodov). Často však chceme pracovať s väčším množstvom dát

• Dnes si ukážeme, ako uložiť väčšie množstvo dát do poľa
• Na niektoré úlohy však pole nepotrebujeme - údaje môžeme spracovávať rovno ako ich užívateľ zadáva (tri takéto príklady na cvičeniach tento týždeň)

V nasledujúcich príkladoch užívateľ zadá číslo N a potom N celých čísel

• Predstavme si napríklad, že učiteľ zadá body, ktoré študenti dostali na písomke (napr. celé čísla v rozsahu 0..10)
• Z týchto bodov chceme spočítať nejaké štatistiky

Priemer

#include <iostream>
using namespace std;

int main(void) {
    int N;
    cout << "Zadaj pocet cisel: ";
    cin >> N;

    int sucet = 0;
    cout << "Zadavaj cisla: ";
    for (int i = 0; i < N; i++) {
        int x;
        cin >> x;
        sucet += x;
    }

    double priemer = sucet / (double) N;
    cout << "Priemer je " << priemer << "." << endl;
}

• Čo by sa stalo, keby sme vo výpočte priemeru vynechali (double)?

Maximum

#include <iostream>
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ť alebo spracovať prvé číslo zvlášť (mimo cyklu)

#include <iostream>
using namespace std;

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

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

    cout << "Zadavajte cisla: ";
    cin >> x;   // načítanie prvého čísla
    max = x;

    for (int i = 1; i < N; i++) {  // cyklus cez N-1 ďalších čísel 
        cin >> x;
        if (x > max) {
            max = x;
        }
    }

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

Cvičenie:

• Ako by sme program rozšírili tak, aby vedel vypísať aj koľké číslo v poradí bolo najväčšie?
• Čo treba v programe zmeniť, ak chceme hľadať minimum namiesto maxima?
• Spočítajte, koľkokrát sa na vstupe vyskytuje číslo 0

Prvé použitie poľa: 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ť
• Na to používame tabuľky, ktoré sa volajú polia.
• Na začiatok pre jednoduchosť predpokladajme, že vopred vieme, že počet údajov N je napr. 20 (N teda nenačítavame)
• Príkaz int a[20]; vytvorí pole s 20 premennými typu int, ku ktorým pristupujeme a[0], a[1], ..., a[19]
  • pozor, a[20] neexistuje

#include <iostream>
using namespace std;

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

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

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

Na zamyslenie:

• 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: ";
   ...

Čo ak ako veľkosť poľa použijeme 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 starších verziách C resp. C++ to nefunguje, aj keď niektoré novšie kompilátory to zvládajú
• Na prednáškach tento spôsob nebudeme používať
• Pole veľkosti N, ktorá nie je konštanta, sa naučíme vytvárať 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

Indexovanie hodnotou mimo intervalu

Pozor, kompilátor nekontroluje indexy prvkov

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

• Skompiluje, 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 neskompiluje – 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;

Výskyty čísel 0...9

Na vstupe je číslo N a N celých čísel od 0 do 9 a chceme vedieť, koľkokrát sa jednotlivé čísla na vstupe vyskytli.

Prvý prístup:

• vstupné čísla uložíme do poľa
• pre každú hodnotu i od 0 po 9 prejdeme pole a spočítame počet výskytov i

Druhý prístup

• samotné vstupné čísla neukladáme do poľa, spracovávame ich po jednom
• vytvoríme si pole počítadiel dĺžky 10, v ktorom p[i] bude počet výskytov čísla i

#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 poľa 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čítadlo pre hodnotu x
        }
    }

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

Odbočka: grafická knižnica SVGdraw

Výsledný obrázok

• Aplikácie s grafickým rozhraním budeme programovať až budúci semester
• V tomto semestri, ale budeme kresliť obrázky v SVG formáte pomocou jednoduchej knižnice #SVGdraw
• Knižnicu si stiahnite a nainštalujte podľa návodu
• Na začiatku programu zapnite knižnicu pomocou #include "SVGdraw.h"
• Tu je malý ukážkový program, ktorý vykreslí zelený štvorec a v ňom červený kruh:

#include "SVGdraw.h"

int main(void) {
  /* Vytvor obrázok s šírkou 150 a výškou 100 a 
   * ulož ho do súboru stvorec.svg*/
  SVGdraw drawing(150, 100, "stvorec.svg");

  /* Nastav farbu vyfarbovania na zelenú. */
  drawing.setFillColor("green");
  /* Vykresli štvorec s ľavým horným 
   * rohom v bode (20,10)
   * a s dĺžkou strany 80, 
   * t.j. pravým dolným rohom 100,90 */
  drawing.drawRectangle(20,10,80,80);
  
  /* Nastav farbu vyfarbovania na červenú */
  drawing.setFillColor("red");
  /* Vykresli kruh so stredom 
   * v bode (60,50) a polomerom 40. */
  drawing.drawEllipse(60,50,40,40);

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

Kreslíme kruhy

Nasledujúci program náhodne vygeneruje súradnice niekoľkých kruhov a vykreslí ich pomocou kružnice SVGdraw.

• Údaje o jednom kruhu si uloží do záznamu struct kruh, v programe používame pole takýchto kruhov.
• Navyše o každom kruhu zistí, či sa pretína s iným kruhom, a ak áno, pri vykresľovaní ho orámuje červenou farbou.

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

struct kruh {
    int x, y; /* suradnice stredu */
    int polomer; /* polomer kruhu */
    bool pretinaSa; /* pretína sa s iným? */
};

void generujKruh(kruh &k, int velkost, int polomer) {
    /* inicializuj kruh s nahodnou polohou 
     * a danym polomerom */
    k.x = rand() % (velkost - 2 * polomer) 
          + polomer;
    k.y = rand() % (velkost - 2 * polomer) 
          + polomer;
    k.polomer = polomer;
}

bool pretinajuSa(kruh &k1, kruh &k2) {
    /* zisti, ci sa dva kruhy pretinaju */
    int dx = k1.x - k2.x;
    int dy = k1.y - k2.y;
    double d2 = sqrt(dx * dx + dy * dy);
    return d2 <= k1.polomer + k2.polomer;
}

int main(void) {
    const int pocet = 10; /* počet kruhov */
    const int velkost = 300; /* veľkosť obrázku */
    const int polomer = 15; /* polomer kruhu */

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

    /* inicializácia obrázku */
    SVGdraw drawing(velkost, velkost, "kruhy.svg");

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

    for (int i = 0; i < pocet; i++) {
        /* kazdemu kruhu vygeneruj nahodnu polohu */
        generujKruh(kruhy[i], velkost, polomer);
    }

    /* zisti, ktoré kruhy pretínajú iné kruhy */
    for (int i = 0; i < pocet; i++) {
        kruhy[i].pretinaSa = false;
        for (int j = 0; j < pocet; j++) {
            if (i != j && pretinajuSa(kruhy[i],
                                      kruhy[j])) {
                kruhy[i].pretinaSa = true;
            }
        }
    }

    /* vykresluj kruhy */
    drawing.setFillColor("gray");
    for (int i = 0; i < pocet; i++) {
        if (kruhy[i].pretinaSa) {
            drawing.setLineColor("red");
        } else {
            drawing.setLineColor("black");
        }
        drawing.drawEllipse(kruhy[i].x, 
                            kruhy[i].y,
                            kruhy[i].polomer,
                            kruhy[i].polomer);
    }

    /* ukoncenie vykreslovania */
    drawing.finish();
}

Polia: 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

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

Prednáška 6

Oznamy

• DÚ1 do piatku 25.10. 22:00
• V stredu o 18:10 písomka, pripravte si ťahák 1 A4

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í, pracujte na domácej úlohe. Kontaktujte nás, ak Vám niečo nie je jasné.
• Dnes algoritmy s poliami.
• Rozcvička zajtra sa pravdepodobne tiež bude týkať polí

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

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

SVGdraw obrázky sú v skutočnosti objekty, väčšinou ich chcete posielať s &

• všetky zmeny na nich spravené pretrvávajú aj po skončení funkcie

#include "SVGdraw.h"
void kresli(SVGdraw &drawing, int n, int y, int rozostup, int velkost) {
   for(int i=0; i<n; i++) {
       drawing.drawRectangle(i*rozostup+velkost, y, velkost, velkost);
   }
}
int main(void) {
    SVGdraw drawing(320, 100, "stvorce.svg");
    kresli(drawing, 10, 50, 30, 10);
    drawing.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

Načo sú v programovaní dobré funkcie

• Rozbijeme veľký problém na menšie dobre definované časti (napr. načítaj pole, utrie pole, vypíš pole), 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, jednu funkciu môžeme zavolať viackrát. 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 poliami.

Funkcie a polia: načítanie a vypísanie poľa

Dve základné funkcie, ktoré sa nám môžu zísť v programoch

• precvičíme si tiež ako sa pracuje s poliami vo funkciách

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


void readArray(int a[], int &n, int maxN) {
    /* Od užívateľa načíta počet vstupných čísel,
     * tento počet uloží do premennej n. 
     * Potom načíta n celých čísel a uloží ich do poľa a,
     * Hodnota maxN je veľkosť poľa,
     * ktorú nemožno prekročiť. */

    cin >> n;
    if (n > maxN) {
        cout << "Prilis velke n!" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
}

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

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

    readArray(a, n, maxN);

    // tu môžeme pole nejako upraviť

    printArray(a, n);
}

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áme for (int i = 0; i < n; i++) { ?
• Ako nahradíme 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ď.

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

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 zapamä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

Triedenia: zhrnutie

• Videli sme tri jednoduché algoritmy na triedenie
• Neskôr sa 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í

Cvičenie:

• Na vstupe sú dve n-prvkové množiny (čísla v množine sa neopakujú, ale môžu byť zadané v ľubovoľnom poradí)
• Zistite, tieto množiny obsahujú rovnaké prvky
  • Viete pri tom použiť triedenie?

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>
#include <cstdlib>
using namespace std;

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

void readArray(int a[], int &n, int maxN) {
    /* Od užívateľa načíta počet vstupných čísel,
     * tento počet uloží do premennej n. 
     * Potom načíta n celých čísel a uloží ich do poľa a,
     * Hodnota maxN je veľkosť poľa,
     * ktorú nemožno prekročiť. */

    cin >> n;
    if (n > maxN) {
        cout << "Prilis velke n!" << endl;
        exit(1);
    }
    for (int i = 0; i < n; i++) {
        cin >> a[i];
    }
}

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) {
    const int maxN = 100;
    int n;
    int a[maxN];

    readArray(a, n, maxN);

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

Prednáška 7

Oznamy

Niektorým sa nedaria cvičenia

• Začiatok semestra je pre začiatočníkov ťažký, ale naučíte sa to len riešením čo najväčšieho počtu príkladov
• Bez dobrej znalosti cyklov, podmienok, premenných, polí a funkcií nebudete rozumieť ďalšiemu učivu a nespravíte skúšku
• Snažte sa každý týždeň vyriešiť čo najviac príkladov
  • Na dobehnutie učiva môžete riešiť aj príklady po termíne, hoci za ne nie sú body
• Skúste sa na cvičeniach pracovať vo dvojici, najlepšie s niekým na podobnej úrovni, striedajte sa pri klávesnici
• Pred cvičením si pozrite poznámky z prednášok
• Dobre si prečítajte zadanie, vrátane príkladu vstupu a výstupu
  • Cieľom príkladu vstupu je aj lepšie ilustrovať zadanie. Skúste si skontrolovať, ako sa asi výstup vypočítal zo vstupu.
• Najskôr si vymyslite postup, ako idete úlohu riešiť. Vytiahnite si papier na poznámky a náčrtky.

Domáca úloha do budúceho piatku

• Preštudujte si zadanie, pýtajte sa otázky
• Časť bodov môžete dostať aj za neúplný program, začnite od jednoduchších častí, napr. načítanie vstupu a uloženie do poľa, vykreslenie domov a pôšt jednotnou farbou
• Potom môžete prejsť na hľadanie najbližšej pošty a správne nastavovanie farieb v obrázku
• Úloha je dobrá príležitosť precvičiť si doteraz preberanú látku

Dnes písomka o 18:10 v posluchárni A, nezabudnite si ťahák, ISIC a písacie potreby

Tento piatok bude na doplnkovom cvičení bonusová rozcvička za 1 bod. V čase cvičenia môžete riešiť aj odinakadiaľ.

• Ak ste v utorok na cvičení vyriešili len 1-2 príklady, odporúčame prísť v piatok na cvičenia

Ďalšie prednášky

• Dnes ešte algoritmy, znaky, v pondelok reťazce (ďalšie precvičenie polí a funkcií, trochu nových pojmov z C)
• Budúcu stredu začneme rekurziu, potenciálne ťažké učivo

Budúci týždeň cvičenia v špeciálnom režime

• Budúci utorok rozcvička a zopár príkladov na znaky a reťazce
• Budúcu stredu po prednáške pribudne 1 menší príklad na rekurziu, v piatok bude opäť bonusová rozcvička na rekurziu
• Odporúčame budúci týždeň na doplnkové cvičenia prísť aj stredne pokročilým programátorom, ak ste ešte nerobili s rekurziou

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 v utriedenom poli

Rýchlejšie vyhľadávane v utriedenom poli 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 prvok a[index] v strede tohoto intervalu, teda index=(left+right)/2
• na základe porovnania s hľadaným prvkom x interval skrátime na polovicu
• 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;
}

Ukážka práce algoritmu pre dva vstupy

int a[7]={2,5,21,32,38,45,50}
x=21
   left=0 right=6: index=3; A[index]>x (32>21)
   left=0 right=2; index=1; A[index]<x (5<21)
   left=2 right=2; index=2; A[index]=x -> return 2
x=11
   left=0 right=6: index=3; A[index]>x (32>11)
   left=1 right=2; index=1; A[index]<x (5<11)
   left=2 right=2; index=2; A[index]>x (21>11)
   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 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

Pre ilustráciu som na mojom počítači som namerala, koľko sekúnd v priemere trvá lineárne a binárne vyhľadávanie v poli s n číslami:

n       lineárne binárne
10      3.1e-8   3.7e-8
100     2.0e-7   6.9e-8
1000    1.8e-6   1.0e-7
10000   1.8e-5   1.4e-7
100000  1.8e-4   1.8e-7
1000000 1.8e-3   2.4e-7

Pripomíname, že napr. 1.8e-3 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.8\cdot 10^{-3}} , t.j. 0.0018. Pri hľadaní v poli dĺžky 10 je teda lineárne vyhľadávanie rýchlejšie, ale v poli dĺžky milión je už vyše 7000 krát pomalšie...

Časová zložitosť triedenia vkladaním

Triedenie 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ť tohto 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 prednášky (výberom a bublinkové) 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 neskôr v semestri

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

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

Hodnota jednoduchého výrazu

Nasledujúci program spočíta hodnotu jednoduchého výrazu, ktorý pozostáva z dvoch čísel spojených znamienkom +, -, * alebo /. Okolo sú medzery (kvôli jednoduchšiemu načítaniu).

Napr. pre vstup 1 / 2 program vypíše 0.5.

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

int main(void) {
    double a, b;
    char znamienko;
    cin >> a >> znamienko >> b;
    double vysledok;
    if (znamienko == '+') {
        vysledok = a + b;
    }
    else if (znamienko == '-') {
        vysledok = a - b;
    }
    else if (znamienko == '*') {
        vysledok = a * b;
    }
    else if (znamienko == '/') {
        vysledok = a / b;
    } else {
        cout << "zle znamienko " << znamienko << endl;
        exit(1);
    }
    cout << vysledok << endl;
}

Switch

• V predchádzajúcom programe bola pomerne dlhá a komplikovaná séria príkazov if, else
• Namiesto toho sa dá použiť 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 (znamienko) {
    case '+' :
        vysledok = a + b;
        break;
    case '-' :
        vysledok = a - b;
        break;
    case '*' :
        vysledok = a * b;
        break;
    case '/' :
        vysledok = a / b;
        break;
    default:
        cout << "zle znamienko " << znamienko << endl;
        exit(1);
    }

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 << "Zadaj n (1,2,3,4): ";
  cin >> n;
  switch (n) {
    case 1: cout << "Jeden" << endl;
    case 2: cout << "Dva" << endl;
    case 3:
    case 4: cout << "Tri alebo styri" << endl;
    default: cout << "Chyba!" << endl;
  }
  cout << "Koniec." << endl;
}

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

Predstavme si, že v programe sa pýtame užívateľa, či chce pokračovať s ďalším vstupom, pričom odpoveď má byť znak 'A' alebo 'N'. Ak by sme program napísali takto, nefungoval by:

    while (true) {
        // nejaky vypocet
        cout << "Chcete pokracovat? (Zadajte odpoved A alebo N)" << endl;
        char odpoved;
        cin >> odpoved;
        switch (odpoved) {
        case 'N':
            break;
        // spracovanie inych pripadov...
        }
    }

• Príkaz break nevyskočí zo všetkých cyklov, ale iba z najvnútornejšieho - a tým je v tomto prípade switch. Program teda pokračuje aj keď užívateľ zadá 'N'.
• Ak by break bol použitý s podmienkou, všetko by fungovalo: while (true) { ... if (odpoved=='N') { break; } }

Ešte znaky

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;            // vypíšeme ho ako číslo
}

Okrem toho však vieme urobiť aj 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 znak

Pretypovanie sme už používali, keď sme chceli dva inty vydeliť bez zaokrúhlenia na celé číslo:

  int a = 5;
  int b = 2;
  cout << a/b << " " << (double)(a/b) << " " << ((double)a)/b << endl;

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

2 2 2.5

Prednáška 8

Oznamy

Body z písomky na testovači

• Opravná písomka v piatok 8.11. o 13:10 v posluchárni F1 328.
• Ak chcete opravnú písomku písať, ale máte konflikt s navrhnutým časom, dajte mi vedieť do zajtra
• Na opravnú písomku sa treba prihlásiť cez AIS alebo VOTR
• Ak prídete na opravnú, strácate body z prvej písomky, aj keď dopadnete horšie
• Celkovo potrebujete z troch písomiek aspoň polovicu bodov, prvá bola najľahšia
• Ak ste z prvej písomky nezískali polovicu bodov, odporúčame vám ísť na opravnú
• Opravenú písomku si môžete pozrieť na cvičeniach, treba vrátiť

Domáca úloha do piatku

• Časť bodov môžete dostať aj za neúplný program
• Ďalšia DÚ zverejnená koncom týždňa

Prednášky a cvičenia tento týždeň

• Dnešná prednáška reťazce
• Zajtra na cvičeniach rozcvička na reťazce plus ďalšie príklady na reťazce, znaky, polia
• Prednáška v stredu rekurzia
• V stredu po prednáške pribudne ďalší príklad na rekurziu a v piatok bonusová rozcvička
  • Rozcvička sa bude dať rátať aj doma v piatok 13:10-22:00
• V rekurzii pokračujeme aj budúci týždeň

Z minulej prednášky

Znaky

• Znakové premenné sú typu char, z anglického character.
• Znaky majú svoje kódy uvedené v tabuľke ASCII.
• Do premennej typu char môžeme priraďovať, jej obsah zapísať alebo prečítať. Znaky môžeme porovnávať pomocou ==, <= atď
• Znakové premenné ukladajú kódy jednotlivých znakov, čo sú celé čísla. Preto medzi znakmi a celými číslami môžeme prechádzať úplne jednoducho.
  • Keď chceme aby výsledok bol konkrétneho typu, použijeme pretypovanie.
• Znakové konštanty sa píšu v apostrofoch, napr. 'A'

Switch

• Namiesto niekoľkých vnorených if s tou istou premennou v podmienke môžeme použiť switch.
• Vo všeobecnosti obsahuje príkaz switch viacero rôznych prípadov vyhodnotenia výrazu v podmienke.

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

Pozor: vykonávanie nekončí vykonaním posledného príkazu v prikazyi, ale pokračuje ďalej, kým nie je prerušené príkazom break.

• Výhodou je, že môžeme zlúčiť viacero prípadov do jednej vetvy.

Využitie znakov

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;

    // kým je načítaný znak číslo (t.j. jedna cifra)
    while ((c >= '0') && (c <= '9')) { 

        // prevod z kódu znaku na cifru 0..9 ('0' má kod 48)
        int cifra = c - '0';
        // upravíme číslo N 
        N = N * 10 + cifra; 
        // a načítame ďalší znak
        cin >> noskipws >> c; 
    }

    if ((c == ' ') || (c == '\n')) { 
        // ak sme skončili medzerou alebo koncom riadku, tak je to pekné číslo
        cout << "Zadali ste " << N << endl;
    } else {
        // ak sme skončili niečim divným, asi to nebude ok
        cout << "Toto je cele cislo?" << endl; 
    }
}

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.

• Napr. reťazec "ABC" je uložený ako pole dĺžky 4 obsahujúci kódy 65, 66, 67, 0 (resp. znaky 'A', 'B', 'C', '\0')
• Pozor, rozdiel medzi znakom s kódom 0 (píše sa aj '\0') a znakom pre cifru nula '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

Keď sme robili funkcie na prácu s poľom čísel, museli sme poslať pole aj počet prvkov. Pri reťazcoch nemusíme zvlášť udržiavať dĺžku, tá je daná pozíciou nuly v poli.

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[6];
    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};
• Namiesto toho sa používa špeciálna skratka: char str[6]="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;     // Výsledkom je 'ves'.
b[0] = 'd';    // Výsledkom je 'des'. 
b[0] = a[1];   // 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

Pre zaujímavosť: ukážka trochu dlhšieho programu na prácu s textom

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

Prednáška 9

Oznamy

Opravná písomka v piatok 8.11. o 13:10

• Ak ju chcete písať, prihláste sa cez AIS alebo VOTR
• Budúci pondelok 28.10. po prednáške vzorové riešenia prvej písomky, určené hlavne pre tých, čo budú písať opravnú

Domáca úloha do piatku

• Časť bodov môžete dostať aj za neúplný program
• Na doplnkových cvičeniach vám môžu poradiť, ak máte otázky, ale nenechávajte všetku prácu na poslednú chvíľu
• Dnes večer pribudne zadanie DÚ2

Cvičenia

• Dnes pribudne do cvičení ďalší príklad na rekurziu, v piatok bonusová rozcvička za jeden bod
• Rozcvička sa bude dať rátať aj doma v piatok 13:10-22:00
• Študentom, ktorí mali problém na písomke, silne odporúčame prísť na doplnkové cvičenia v piatok. Po dohode s cvičiacimi v piatok môžete dostať príležitosť vyriešiť za body aj niektorý zo starších príkladov, ktoré už sú po termíne odovzdania.

Klasické úvodné príklady na rekurziu

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\le 1 \\ 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 <= 1) return 1;
    else return n * factorial(n-1);
}

Aby sa 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 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 r = a % b;
        a = b;
        b = r;
    }
    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

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ú definované rekurzívne:

• F(0)=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 == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        return fib(n - 1) + fib(n - 2);
    }
}

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

int fibonacci(int n) {
    if (n == 0) {
        return 0;
    } else if (n == 1) {
        return 1;
    } else {
        int F_posledne = 1;
        int F_predposledne = 0;
        for (int i = 2; i <= n; i++) {
            int F_n = F_posledne + F_predposledne;
            F_predposledne = F_posledne;
            F_posledne = F_n;                     
        }
        return F_posledne;
    }
}

Binárne vyhľadávanie

Aj binárne vyhľadávanie prvku v utriedenom poli z prednášky 7 sa dá pekne zapísať rekurzívne.

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 testovanie párnosti a nepárnosti (len ilustračný príklad, párnosť zvačajne testujeme pomocou n%2):

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 s funkciami
• 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 sa 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). 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.

Odbočka: korytnačia grafika v SVGdraw

Náš prvý dnešný príklad rekurzie budú rekurzívne obrázky, fraktály. Aby sa nám lepšie vykresľovali, v knižnici SVGdraw je možnosť kresliť pomocou korytnačej grafiky.

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

Napríklad na vykreslenie štvorca s dĺžkou strany 100 môžeme korytnačke striedavo prikazovať ísť o 100 dopredu a otáčať sa o 90 stupňov doľava.

• Na obrázku sa animuje pohyb korytnačky (pozri tu)
• Program by sa dal ľahko rozšíriť na vykresľovanie pravidelného n-uholníka (stačí zmeniť uhol otočenia a počet opakovaní cyklu)

#include "SVGdraw.h"

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

    for (int i = 0; i < 4; i++) {
        turtle.forward(150);  /* vykresli čiaru dĺžky 100 */
        turtle.turnLeft(90);  /* otoč sa doľava o 90 stupňov */
    }
    /* strany sú vykreslené v poradí dolná, pravá, horná, ľavá */

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

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.

Ḱochova krivka

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 použijeme 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();
}

Rekurzívny strom

A ešte jeden príklad fraktálu: strom definovaný nasledovne:

• 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 d 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)

• 

  Strom stupňa 1

• 

  Strom stupňa 2

• 

  Strom stupňa 3

• 

  Strom stupňa 5

Rekurzívnu funkciu na vykresľovanie stromu napíšeme tak, aby sa po skončení vrátila na miesto a otočenie, kde začala

• Bez toho by sa sme nevedeli, kde korytnačka je po vykreslení ľavého podstromu a nemohli by sme teda kresliť pravý
• Korytnačka teda prejde po každej vetve dvakrát, raz smerom dopredu a raz naspäť.

#include "SVGdraw.h"

void drawTree(double d, int n, Turtle& turtle) {
    if (n == 0) {
        /* stupen 0 - nerob nic */
        return;  
    } else {
        /* kmen stromu */
        turtle.forward(d);              
        turtle.turnLeft(30);
        /* lava cast koruny */
        drawTree(d / 2, n - 1, turtle); 
        turtle.turnRight(60);
        /* prava cast koruny */
        drawTree(d / 2, n - 1, turtle); 
        turtle.turnLeft(30);
        /* navrat na spodok kmena */
        turtle.forward(-d);             
    }
}

int main(void) {
    /* rozmery obrazku */
    int width = 150; 
    int height = 200;

    /* velkost stromu */
    double d = 100; 
    /* stupen krivky */
    int n = 5; 

    /* vytvor korytnačku otočenú hore */
    Turtle turtle(width, height, "fraktal.svg", 
                  width / 2, height - 10, 90);

    /* nakresli strom rekurzívne */
    drawTree(d, n, turtle);

    /* schovaj korytnačku */
    turtle.finish();
}

Hanojské veže

• Problém Hanojských veží pozostáva z troch tyčí a niekoľkých kruhov rôznej veľkosti. Začína sa postavením pyramídy z kruhov (kameňov) na prvú tyč od najväčšieho po najmenší.
• Úlohou je potom presunúť celú pyramídu na inú tyč, 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ší

Úlohu budeme riešiť rekurzívne

• Ak máme iba jeden kameň, úloha je veľmi jednoduchá - preložíme ho z pôvodnej tyče na cieľovú tyč.
• Ak chceme preložiť viac kameňov (nech ich je N), tak
  • Všetky okrem posledného preložíme na pomocnú tyč (na to použijeme taký istý postup len s N-1 kameňmi)
  • Premiestnime najväčší kameň na cieľovú tyč
  • Zatiaľ odložené kamene (na pomocnej tyči) preložíme z pomocného na cieľovú tyč (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 jeden 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)

void presunHanoi(int odkial, int cez, int kam, int n) {
    if (n == 1) {
        cout << "Prelozim kamen z " << odkial 
             << " na " << kam << endl;
    } else {
        // odlozime n-1 na docasnu tyc cez
        presunHanoi(odkial, kam, cez, n-1); 
        // prelozime najvacsi kamen na finalnu tyc kam
        presunHanoi(odkial, cez, kam, 1);   
        // zvysnych n-1 prelozime z docasnej tyce na finalnu
        presunHanoi(cez, odkial, kam, n-1); 
    }
}

int main (void) {
    // z tyce 1 na tyc 3 (pomocou tyce 2)
    presunHanoi(1, 2, 3, 3); 
}

Dôležité je si uvedomiť, že nasledovný postup dodržuje pravidlá. Po zavolaní funkcie presunHanoi vždy platí:

• Funkcia bude presúvať n horných kameňov z tyče odkial na tyč kam pomocou pomocnej tyče cez.
• Ak n>1, tak na tyčiach kam a cez sú len väčšie kamene ako horných n kameňov na odkial.
• Ak n=1, na tyči kam sú len väčšie kamene, obsah tyče cez môže byť ľubovoľný.

Prednáška 10

Oznamy

• Zajtrajšia rozcvička bude z dnešnej prednášky
  • Tento týždeň iba 3 príklady na cvičeniach, spolu 6 bodov
• V piatky 1.11. a 8.11. nebudú doplnkové cvičenia. Namiesto toho budú náhradné doplnkové cvičenia v pondelky 4. a 11.11. o 11:30 v miestnosti M217, kde ste vítaní, ak máte nejaké otázky alebo si chcete samostatne riešiť príklady.
• DÚ2 je zverejnená, odovzdávajte do pondelka 11.11. 22:00
• Druhá písomka bude v stredu 21.11. o 18:10 v posluchárni A, tretia 11.12.
• Dnes po prednáške vzorové riešenia prvej písomky

Opakovanie rekurzie

• 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)
  • Nezabudnime na triviálne prípady, napr. F(0)=F(1)=1

• 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 == 0) {
        return 0;
    } else if (n == 1) {
        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

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

Zásobník volaní

Druhý pohľad na rekurziu je dynamický: môžeme simulovať, čo sa v programe deje so zásobníkom volaní (call stack)

• 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 == 0) {
        return 0;
    } else if (n == 1) {
        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=0, 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=1, b=?, riadok A     fib n=3, a=1, b=?, riadok B 
main, x=?, riadok C             main, x=?, riadok C                 


(10)                            (11)

fib n=3, a=1, b=1, riadok B     
main, x=?, riadok C             main, x=2, riadok C 

Pozor, 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

Postupnosť volaní počas výpočtu vieme znázorniť aj stromovým diagramom:

Ako by sme zistili, čo robí rekurzívna funkcia, napríklad takáto obmena Fibonacciho postupnosti?

int f(int n) {
    if (n <= 2) return 1;
    else return f(n-1) + f(n-3);
}

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:

000
001
010
011
100
101
110
111

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

012
021
102
120
201
210

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é?

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, vypiseme 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 << "{";
    bool prve = true;
    for (int i = 0; i < m; i++) {
        if (a[i] == 1) {
            if (prve) {
                cout << "" << i;
                prve=false;
            } else {
                cout << "," << i;
            }
        }
    }
    cout << "}" << endl;
}

• V premennej prve si pamätáme, či 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 << "{";
    bool prve = true;
    for (int i = 0; i < m; i++) {
        if (a[i]) {
            if (prve) {
                cout << "" << i;
                prve=false;
            } else {
                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 program vypísal, ak by sme prehodili true a false v rekurzii?

Prednáška 11

Oznamy

• V piatky 1.11. a 8.11. nebudú doplnkové cvičenia. Namiesto toho budú náhradné doplnkové cvičenia v pondelky 4. a 11.11. o 11:30 v miestnosti M217, kde ste vítaní, ak máte nejaké otázky alebo si chcete samostatne riešiť príklady.
• DÚ2 je zverejnená, odovzdávajte do pondelka 11.11. 22:00
• Nezabudnite, že ak z cvičení za týždeň neodovzdáte úspešne ani jeden príklad, dostanete -5 bodov. Takisto je vhodné nazbierať z DÚ a cvičení aspoň polovicu bodov, lebo inak budete mať problém získať celkovo dosť bodov z predmetu.
• Na DÚ pracujte samostatne. Ak nájdeme prípad opisovania, všetky zúčastnené strany dostanú z úlohy 0 bodov.
• V utorok 5.11. od 16:30 bude v H6 Linux Installfest, kde vám dobrovoľníci môžu pomôcť na váš notebook nainštalovať Linux.
  • Prineste si notebook s odzálohovanými dátami (pre istotu) a prázdny USB kľúč

Prehľadávanie s návratom (backtracking)

• Videli sme ako rekurzívne generovať všetky postupnosti spĺňajúce určité požiadavky
• Ak máme špeciálne požiadavky, napr. že žiadne číslo sa neopakuje, môžeme buď generovať všetky k-tice a testovať to pred výpisom, alebo už počas generovania urezávať neprespektívne vetvy výpočtu, čo je rýchlejšie
• Táto technika sa dá použiť na riešenie rôznych hlavolamov, videli sme problém 8 dám.
• Dá sa použiť aj na reálne problémy, ale pozor, čas výpočtu prudko (exponenciálne) rastie s dĺžkou postupností, takže vhodné len pre malé vstupy.
• Dnes ešte jeden problém riešený prehľadávaním s návratom, kde medzi možnými riešeniami hľadáme najlepšie.

Problém batoha (Knapsack problem)

Metódu prehľadávania s návratom využijeme na riešenie tzv. problému batoha. Ide o dôležitý problém, s ktorým sa ešte počas štúdia stretnete. Populárne ho možno sformulovať napríklad takto:

• Zlodej sa vlúpal do obchodu, v ktorom našiel nejaký počet „odcudziteľných” predmetov
• Pozná cenu aj hmotnosť predmetov.
• Z obchodu dokáže odniesť iba lup nepresahujúci nosnosť svojho batoha.
• Ktoré predmety má zlodej odcudziť, aby ich celková hmotnosť nepresahovala nosnosť batoha a aby odišiel s čo najcennejším lupom?

Vstup nášho programu bude vyzerať napríklad nejako takto:

Zadaj pocet predmetov v obchode: 3
Zadaj hmotnost a cenu predmetu cislo 1: 5 9
Zadaj hmotnost a cenu predmetu cislo 2: 4 6
Zadaj hmotnost a cenu predmetu cislo 3: 4 4
Zadaj nosnost batoha: 8

Výstup programu na horeuvedenom vstupe potom bude takýto:

Zober nasledujuce predmety: 2, 3.
Celkova hodnota lupu: 10.

Pri reálnom použití nosnosť batoha môže reprezentovať dostupné zdroje, napr. výpočtový čas na serveri, dostupných pracovníkov, veľkosť rozpočtu a pod, a predmety sú potenciálne úlohy, z ktorých si chceme vybrať podmnožinu, ktorú by sme s danými zdrojmi vedeli vykonať a dosiahnuť čo najvyšší zisk alebo iný ukazovateľ.

Prvé riešenie: preskúmanie všetkých možných výberov

Najjednoduchšie riešenie problému batoha spočíva v preskúmaní všetkých podmnožín množiny predmetov v obchode – čiže všetkých potenciálnych lupov. Program vypisujúci všetky podmnožiny danej množiny mierne poupravíme – nebudeme nájdené podmnožiny predmetov (potenciálne lupy) vypisovať, ale zakaždým:

• Spočítame celkovú hmotnosť a cenu nájdeného potenciálneho lupu.
• Ak hmotnosť tohto lupu nepresahuje cenu batoha, porovnáme jeho cenu s najlepším doposiaľ nájdeným lupom.
• Ak je cennejší, ako doposiaľ najlepší lup, ide o nového kandidáta na optimálny lup.

Podmnožiny budeme reprezentovať poľom typu bool, v ktorom si pre každý predmet pamätáme, či do danej podmnožiny patrí.

#include <iostream>
using namespace std;

const int maxN = 100;

/* Struktura reprezentujuca jeden predmet */
struct predmet {
    int hmotnost;
    int cena;
}; 

/* Globalne premenne pouzivane v rekurzii: */

// pocet predmetov v obchode
int N;                         
// pole s udajmi o jednotlivych predmetoch
predmet a[maxN];                 
// nosnost batoha
int nosnost;                     

// najcennejsi doposial najdeny potencialny lup (na uvod neinicializovany)
bool najlepsiLup[maxN];          
// jeho cena (kazdy lup bude urcite cennejsi ako -1)
int cenaNajlepsiehoLupu = -1;    

int spocitajHmotnostLupu(bool lup[]) {
    int hmotnost = 0;
    for (int i = 0; i < N; i++) {
        if (lup[i]) {
            hmotnost += a[i].hmotnost;
        }
    }
    return hmotnost;
}

int spocitajCenuLupu(bool lup[]) {
    int cena = 0;
    for (int i = 0; i < N; i++) {
        if (lup[i]) {
            cena += a[i].cena;
        }
    }
    return cena;
}

void vypisLup(bool lup[]) {
    cout << "Zober nasledujuce predmety: ";
    bool prvy = true;
    for (int i = 0; i < N; i++) {
        if (lup[i]) {
            if (prvy) {
                cout << i + 1;
                prvy = false;
            } else {
                cout << ", " << i + 1;
            }        
        }    
    }
    cout << "." << endl;
}

/* Generovanie vsetkych moznych lupov (podmnozin predmetov) */
void generujLupy(bool lup[], int index) {
    /* V poli lup[] dlzky N postupne generujeme podmnoziny predmetov.
       O hodnotach prvkov lup[0],...,lup[index-1] uz je rozhodnute.
       Postupne vygenerujeme vsetky moznosti pre lup[index],...,lup[N-1].
       Kazdy vysledny lup porovname s doposial najlepsim 
       a v pripade potreby optimum aktualizujeme.    
    */
    if (index == N) {                                
        // Lup je vygenerovany; zisti, ci ho batoh unesie.                               
        if (spocitajHmotnostLupu(lup) <= nosnost) {  
            // Ak ano, porovnaj cenu lupu s doposial najlepsim.
            int cenaLupu = spocitajCenuLupu(lup);
            if (cenaLupu > cenaNajlepsiehoLupu) {    
                // Ak je najdeny lup drahsi, uloz ho
                cenaNajlepsiehoLupu = cenaLupu;
                for (int i = 0; i < N; i++) {
                    najlepsiLup[i] = lup[i];
                } 
            }
        }
    } else {                                         
        // Lup este nie je vygenerovany,
        // skus postupne obe moznosti pre lup[index]. 
        lup[index] = false;
        generujLupy(lup, index+1);
        lup[index] = true;
        generujLupy(lup, index+1);
    }
} 

int main() {
    cout << "Zadaj pocet predmetov v obchode: ";
    cin >> N;
    for (int i = 0; i < N; i++) {
        cout << "Zadaj hmotnost a cenu predmetu cislo " << (i+1) << ": ";
        cin >> a[i].hmotnost >> a[i].cena;
    }
    cout << "Zadaj nosnost batoha: ";
    cin >> nosnost;
    
    bool lup[maxN];
    generujLupy(lup, 0);
    
    cout << endl;
    vypisLup(najlepsiLup);
    cout << "Celkova hodnota lupu: " << cenaNajlepsiehoLupu << "." << endl;
}

Optimalizácia č. 1: ukončenie prehľadávania vždy, keď je prekročená nosnosť

Keď je už po vygenerovaní nejakej časti lupu (čiže prvých niekoľko hodnôt poľa lup) jasné, že jeho hmotnosť bude presahovať nosnosť batoha, možno túto vetvu prehľadávania ukončiť.

Okrem samotnej funkcie generujLupy je potrebné prispôsobiť aj funkciu spocitajHmotnostLupu tak, aby ju bolo možné aplikovať aj na „neúplne vygenerované lupy”.

/* Potrebujeme vediet spocitat hmotnost len pre cast predmetov: */

int spocitajHmotnostLupu(bool lup[], int pokial) {
    int hmotnost = 0;
    for (int i = 0; i <= pokial; i++) {
        if (lup[i]) {
            hmotnost += a[i].hmotnost;
        }
    }
    return hmotnost;
}

void generujLupy(bool lup[], int index) {
    if (spocitajHmotnostLupu(lup, index-1) > nosnost) {
        // Ak dosial vygenerovana cast lupu presahuje nosnost batoha, 
        // mozno prehladavanie ukoncit
        return;  
    }
    if (index == N) {
        int cenaLupu = spocitajCenuLupu(lup);
        if (cenaLupu > cenaNajlepsiehoLupu) {
            cenaNajlepsiehoLupu = cenaLupu;
            for (int i = 0; i < N; i++) {
                najlepsiLup[i] = lup[i];
            } 
        }
    } else {
        lup[index] = false;
        generujLupy(lup, index+1);
        lup[index] = true;
        generujLupy(lup, index+1);
    }
}

Optimalizácia č. 2: hmotnosť a cenu lupu netreba zakaždým počítať odznova

Predchádzajúci program vždy znovu a znovu prepočítava hmotnosť a cenu lupu, aj keď sa zoznam vybraných predmetov zmení iba trochu. Namiesto toho môžeme cenu a hmotnosť doposiaľ vygenerovanej časti lupu predávať funkcii generuj ako parameter.

#include <iostream>
using namespace std;

const int maxN = 100;

struct predmet {
    int hmotnost;
    int cena;
}; 

int N;
predmet a[maxN];
int nosnost;

bool najlepsiLup[maxN];
int cenaNajlepsiehoLupu = -1;

void vypisLup(bool lup[]) {
    cout << "Zober nasledujuce predmety: ";
    bool prvy = true;
    for (int i = 0; i < N; i++) {
        if (lup[i]) {
            if (prvy) {
                cout << i + 1;
                prvy = false;
            } else {
                cout << ", " << i + 1;
            }        
        }    
    }
    cout << "." << endl;
}

void generujLupy(bool lup[], int index, int hmotnostLupu, int cenaLupu) {
    if (hmotnostLupu > nosnost) {
        return;
    }
    if (index == N) {
        if (cenaLupu > cenaNajlepsiehoLupu) {
            cenaNajlepsiehoLupu = cenaLupu;
            for (int i = 0; i < N; i++) {
                najlepsiLup[i] = lup[i];
            } 
        }
    } else {
        lup[index] = false;
        generujLupy(lup, index+1, hmotnostLupu, cenaLupu);
        lup[index] = true;
        generujLupy(lup, index+1, hmotnostLupu + a[index].hmotnost, 
                    cenaLupu + a[index].cena);
    }
} 

int main() {
    cout << "Zadaj pocet predmetov v obchode: ";
    cin >> N;
    for (int i = 0; i < N; i++) {
        cout << "Zadaj hmotnost a cenu predmetu cislo " << (i+1) << ": ";
        cin >> a[i].hmotnost >> a[i].cena;
    }
    cout << "Zadaj nosnost batoha: ";
    cin >> nosnost;
    
    bool lup[maxN];
    // Doposial nie je nic vygenerovane; hmotnost aj cena lupu su zatial nulove
    generujLupy(lup, 0, 0, 0); 
    
    cout << endl;
    vypisLup(najlepsiLup);
    cout << "Celkova hodnota lupu: " << cenaNajlepsiehoLupu << "." << endl;
}

Rýchle triedenia prostredníctvom paradigmy „rozdeľuj a panuj”

Doposiaľ sme prebrali tri triediace algoritmy: Bubble Sort, Insertion Sort a Max Sort. Všetky sú jednoduché, ale pomalé: majú 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 pridáme ďalšie dve triedenia, ktoré budú veľké polia omnoho rýchlejšie: Merge Sort a Quick Sort. Obe sú založené na paradigme rozdeľuj a panuj (angl. divide and conquer, lat. divide et impera).

Rozdeľuj a panuj je paradigma rekurzívneho riešenia problémov pracujúca v troch fázach:

• Rozdeľuj – problém rozdelíme na menšie časti (t.j. podproblémy), ktoré sa dajú riešiť samostatne.
• Vyrieš podproblémy – rekurzívne vyriešime úlohu pre každý podproblém.
• Panuj – riešenia podproblémov spojíme do riešenia pôvodného problému.

Triedenie zlučovaním (Merge Sort)

Triedenie zlučovaním (angl. Merge Sort) pracuje nasledovne:

• Pole rozdelíme na dve približne rovnaké časti
• Každú časť zvlášť rekurzívne utriedime
• Vo fáze „panuj” sa tieto dve utriedené postupnosti zlúčia (angl. merge) do výsledného utriedeného poľa.

Triedenie zlučovaním tak bude vyzerať nasledovne (pričom zostáva doimplementovať funkciu merge):

void mergesort(int a[], int left, int right) {
/* Funkcia utriedi prvky pola a[] od indexu left po index right (vratane). */
    
    /* Trivialne pripady: */
    if (left >= right) {
        return;           
    }
    
    /* Rozdeluj -- spocitaj priblizny stred triedeneho useku: */
    int middle = (left + right) / 2;
          
    /* Rekurzivne vyries podproblemy: */
    mergesort(a,left,middle);
    mergesort(a,middle+1,right);
       
    /* Panuj -- zluc obe utriedene casti do jednej: */ 
    merge(a,left,middle,right);
}

Zlúčenie dvoch utriedených podpostupností

Zostáva doprogramovať zlúčenie dvoch utriedených podpostupností a[left..middle], a[middle+1..right] do jednej utriedenej postupnosti. Zlúčenú postupnosť budeme postupne ukladať do pomocného poľa aux, pričom postupovať budeme nasledovne:

• Prvým prvkom poľa aux bude menší z prvkov a[left] a a[middle+1].
  • Ostanú nám postupnosti a[left+1..middle] a a[middle+1..right] alebo a[left..middle] a a[middle+2..right].
• Vo všeobecnosti máme postupnosti a[i..middle] a a[j..right].
  • Ďalším prvkom poľa aux bude menčí z prvkov a[i] a a[j]
  • Ostanú nám postupnosti a[i+1..middle] a a[j..right] alebo a[i..middle] a a[j+1..right].
• Toto robíme dovtedy, kým niektorú z postupností nevyčerpáme celú. Potom už len na koniec poľa aux dokopírujeme zvyšok druhej postupnosti.

Po spojení oboch postupností do utriedeného poľa aux toto pole prekopírujeme naspäť do poľa a.

void merge(int a[], int left, int middle, int right) {
    int aux[maxN];
    int i = left;     // index v prvej postupnosti
    int j = middle+1; // index v druhej postupnosti
    int k = 0;        // index v poli aux
    
    while (i <= middle && j <= right) { 
        // Kym su obe postupnosti a[i..middle], a[j..right] neprazdne,
        // mensi z prvkov a[i], a[j] uloz do aux[k] a posun indexy
        if (a[i] <= a[j]) {                         
            aux[k] = a[i];
            i++;
            k++;
        } else {
            aux[k] = a[j];
            j++;
            k++;
        }
    }
    
    while (i <= middle) {  
        // Ak nieco ostalo v prvej postupnosti, dokopiruj ju na koniec
        aux[k] = a[i];
        i++;
        k++;
    }
    
    while (j <= right) { 
        // Ak nieco ostalo v druhej postupnosti, dokopiruj ju na koniec
        aux[k] = a[j];
        j++;
        k++;
    }
    
    for (int t = left; t <= right; t++) { 
        // Prekopiruj pole aux naspat do pola a
        a[t] = aux[t - left];
    }
}

Výsledný program

#include <iostream>
using namespace std;

const int maxN = 1000;

void merge(int a[], int left, int middle, int right) {
    int aux[maxN];
    int i = left;
    int j = middle+1;
    int k = 0;
    
    while (i <= middle && j <= right) {
        if (a[i] <= a[j]) {
            aux[k] = a[i];
            i++;
            k++;
        } else {
            aux[k] = a[j];
            j++;
            k++;
        }
    }
    
    while (i <= middle) {
        aux[k] = a[i];
        i++;
        k++;
    }
    
    while (j <= right) {
        aux[k] = a[j];
        j++;
        k++;
    }
    
    for (int t = left; t <= right; t++) {
        a[t] = aux[t - left];
    }
}

void mergesort(int a[], int left, int right) {
    if (left >= right) {
        return;
    }
    
    int middle = (left + right) / 2;
          
    mergesort(a, left, middle);
    mergesort(a, middle+1, right);
       
    merge(a, left, middle, right);
}

int main() {
    int N;
    int a[maxN];
    
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    cout << "Zadaj " << N << " cisel: ";
    for (int i = 0; i < N; i++) {
        cin >> a[i];
    }
    
    mergesort(a,0,N-1);
    
    cout << "Utriedene cisla:";
    for (int i = 0; i < N; i++) {
        cout << " " << a[i];
    }                        
    cout << endl;
}

Ukážka na príklade

Uvažujme pole a = {6, 1, 5, 7, 2, 4, 8, 9, 3, 0}.

Volanie mergesort(a,0,9) potom utriedi pole a pomocou nasledujúcich rekurzívnych volaní (namiesto mergesort(a,l,h) budeme písať vždy len sort(l,h) a namiesto merge(a,l,m,h) len merge(l,m,h)):

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)

Pole a sa počas týchto volaní mení nasledovne:

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

Quick Sort

Quick Sort je tiež založený na metóde rozdeľuj a panuj. Postupuje ale nasledovne:

• V rámci fázy rozdeľuj vyberie niektorý prvok poľa (napríklad jeho prvý prvok), ktorý nazve pivotom. Prvky poľa následne preusporiada na tri skupiny: v ľavej časti poľa budú prvky menšie ako pivot, za nimi pivot samotný a napokon v pravej časti prvky väčšie alebo rovné ako pivot.
• Rekurzívne utriedi prvú a tretiu skupinu (druhá skupina má iba jeden prvok)
• Vo fáze panuj už potom nemusí robiť nič – po utriedení spomínaných dvoch skupín totiž vznikne utriedené pole.

Základ triedenia tak bude vyzerať nasledovne (pričom zostáva implementovať funkciu partition):

void quicksort(int a[], int left, int right) {
/* Utriedi cast pola a[] od indexu left po index right (vratane) */

    /* Trivialne pripady: */ 
    if (left >= right) {
        return; 
    }
    
    /* Rozdel pole na tri podpostupnosti: */ 
    int middle = partition(a, left, right); 
    // Po vykonani funkcie: 
    // a[left..middle-1] su mensie ako pivot 
    // a[middle] je pivot
    //  a[middle+1..right] su vacsie ako pivot
    
    /* Rekurzivne utried a[left..middle-1], a[middle+1..right]: */    
    quicksort(a, left, middle-1);  
    quicksort(a, middle+1, right);   
}

Funkcia partition

Funkcia partition na vstupe dostane pole a spolu s hraničnými indexami left a right. Prvok a[left] vyberie ako pivot a postupnosť a[left..right] preusporiada tak, aby pre nejakú hodnotu middle takú, že left <= middle <= right platilo nasledovné:

• Prvky a[left],...,a[middle-1] sú menšie, než pivot.
• Prvok a[middle] je pivot.
• Prvky a[middle+1],...,a[right] sú väčšie alebo rovné ako pivot.

Hodnotu middle potom funkcia partition vráti ako svoj výstup.

Funkcia partition udržiava nasledujúce invarianty:

• Prvok a[left] je pivot.
• Prvky a[left+1],...,a[lastSmaller] sú menšie ako pivot.
• Prvky a[lastSmaller+1],...,a[unknown-1] sú väčšie alebo rovné ako pivot.
• Prvky a[unknown],...,a[right] sa ešte s pivotom neporovnávali.

Funkcia partition zakaždým porovnáva prvok a[unknown] s pivotom:

• Ak je menší ako pivot, je nutné „presunúť ho doľava”; vymení ho teda s a[lastSmaller+1] a hodnotu lastSmaller zvýši o jedna.
• Ak je väčší alebo rovný ako pivot, môže ostať na svojom mieste.

Následne zvýši index unknown o jedna a tento postup opakuje, až kým prejde cez všetky prvky danej časti poľa.

Nakoniec je ešte nutné vymeniť a[left] s a[lastSmaller], čím sa pivot dostane na svoje miesto.

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

int partition(int a[], int left, int right) {
    // Ak za pivot chceme zvolit iny prvok, vymenime ho najprv s a[left]
    int pivot = a[left];     
    int lastSmaller = left;
    
    for (int unknown = left + 1; unknown <= right; unknown++) {
        if (a[unknown] < pivot) {
            lastSmaller++;
            swap(a[unknown], a[lastSmaller]);
        }
    }   
    swap(a[left],a[lastSmaller]); 
    return lastSmaller;
}

Výsledný program

#include <iostream>
using namespace std;

const int maxN = 1000;

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

int partition(int a[], int left, int right) {
    int pivot = a[left];
    int lastSmaller = left;
    
    for (int unknown = left + 1; unknown <= right; unknown++) {
        if (a[unknown] < pivot) {
            lastSmaller++;
            swap(a[unknown], a[lastSmaller]);
        }
    }   
    swap(a[left],a[lastSmaller]); 
    return lastSmaller;
}

void quicksort(int a[], int left, int right) {
    if (left >= right) {
        return; 
    }
    
    int middle = partition(a, left, right);
        
    quicksort(a, left, middle-1);  
    quicksort(a, middle+1, right);   
}

int main() {
    int N;
    int a[maxN];
    
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    cout << "Zadaj " << N << " cisel: ";
    for (int i = 0; i <= N-1; i++) {
        cin >> a[i];
    }
    
    quicksort(a,0,N-1);
    
    cout << "Utriedene cisla:";
    for (int i = 0; i <= N-1; i++) {
        cout << " " << a[i];
    }                        
    cout << endl;
}

Ukážka na príklade

Opäť uvažujme pole a = {6, 1, 5, 7, 2, 4, 8, 9, 3, 0}.

Volanie quicksort(0,9) potom utriedi pole a pomocou nasledujúcich rekurzívnych volaní (namiesto quicksort(a,l,h) píšeme zakaždým len sort(l,h)):

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)

Volania funkcie partition sú počas tohto behu nasledovné:

partition(a,0,9): |6 1 5 7 2 4 8 9 3 0| -> |0 1 5 2 4 3|6|9 7 8|
partition(a,0,5): |0 1 5 2 4 3|6 9 7 8  -> |0|1 5 2 4 3|6 9 7 8
partition(a,1,5):  0|1 5 2 4 3|6 9 7 8  ->  0|1|5 2 4 3|6 9 7 8
partition(a,2,5):  0 1|5 2 4 3|6 9 7 8  ->  0 1|3 2 4|5|6 9 7 8
partition(a,2,4):  0 1|3 2 4|5 6 9 7 8  ->  0 1|2|3|4|5 6 9 7 8
partition(a,7,9):  0 1 2 3 4 5 6|9 7 8| ->  0 1 2 3 4 5 6|8 7|9|
partition(a,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 Quick Sort správať, keď na vstupe dostane už utriedené pole?
• Ako sa bude správať, keď na vstupe dostane zostupne utriedené pole?

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

• 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 možno stretnúť aj s nasledujúcou implementáciou triedenia Quick Sort. Skúste samostatne odôvodniť jej správnosť.

void quicksort(int a[], int left, int right) {
    if (left >= right) {
        return;
    }
    
    /* partition */
    int pivot = a[(left + right)/2];
    int i = left;
    int j = right;
    
    while (i <= j) {
        while (a[i] < pivot) i++;
        while (a[j] > pivot) j--;
        if (i <= j) {
            swap(a[i],a[j]);
            i++; j--;
        }
    }
    
    /* rekurzia */    
    quicksort(a, left, j);
    quicksort(a, i, right);   
}

Triediace algoritmy: zhrnutie

Jednoduché triedenia: Bubble Sort, Insertion Sort, Max Sort.

• 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 založené na technike rozdeľuj a panuj.

• Rýchlejšie, zložitejšie.
• Merge Sort: 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)} .
• Quick Sort: 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 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\log n)} , väčšinou rýchlejší ako Merge Sort.

Reálnu rýchlosť triedení na náhodne zvolenom veľkom vstupe možno porovnať napríklad nasledujúcim programom:

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

const int maxN = 100000;

void insertionsort(int a[], int n) {
    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;
    }
}

void merge(int a[], int left, int mid, int right) {
    int aux[maxN];
    int i = left;
    int j = mid + 1;
    int k = 0;

    while ((i <= mid) && (j <= right)) {
        if (a[i] <= a[j]) {
            aux[k] = a[i];
            i++;
            k++;
        } else {
            aux[k] = a[j];
            j++;
            k++;
        }
    }

    while (i <= mid) {
        aux[k] = a[i];
        i++;
        k++;
    }

    while (j <= right) {
        aux[k] = a[j];
        j++;
        k++;
    }

    for (int k = left; k <= right; k++) {
        a[k] = aux[k - left];
    }
}

void mergesort(int a[], int left, int right) {
    if (left >= right) {
        return;
    }

    int mid = (left + right) / 2;

    mergesort(a, left, mid);
    mergesort(a, mid + 1, right);

    merge(a, left, mid, right);
}

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

int partition(int a[], int left, int right) {
    int pivot = a[left];
    int lastSmaller = left;

    for (int unknown = left + 1; unknown <= right; unknown++) {
        if (a[unknown] < pivot) {
            lastSmaller++;
            swap(a[unknown], a[lastSmaller]);
        }
    }
    swap(a[left], a[lastSmaller]);
    return lastSmaller;
}

void quicksort(int a[], int left, int right) {
    if (left >= right) {
        return;
    }

    int mid = partition(a, left, right);

    quicksort(a, left, mid - 1);
    quicksort(a, mid + 1, right);
}

int main() {
    int N;
    int a1[maxN];
    int a2[maxN];
    int a3[maxN];

    cout << "Zadaj pocet nahodnych cisel v poli: ";
    cin >> N;

    srand(time(NULL));
    for (int i = 0; i <= N - 1; i++) {
        a1[i] = rand() % 1000;
        a3[i] = a2[i] = a1[i];
    }

    clock_t start1, end1, start2, end2, start3, end3;

    start1 = clock();
    insertionsort(a1, N);
    end1 = clock();

    start2 = clock();
    mergesort(a2, 0, N - 1);
    end2 = clock();

    start3 = clock();
    quicksort(a3, 0, N - 1);
    end3 = clock();

    cout << "Insertion sort: " 
	 << (end1 - start1) * 1.0 / CLOCKS_PER_SEC << " CPU sekund" << endl;
    cout << "Merge sort: " 
	 << (end2 - start2) * 1.0 / CLOCKS_PER_SEC << " CPU sekund" << endl;
    cout << "Quick sort: " 
	 << (end3 - start3) * 1.0 / CLOCKS_PER_SEC << " CPU sekund" << endl;

}

Pre N = 100000 môžeme dostať napríklad nasledujúci výstup (líši sa od počítača k počítaču a od volania k volaniu):

Insertion sort: 7.474 CPU sekund
Merge sort: 0.076 CPU sekund
Quick sort: 0.032 CPU sekund

Prednáška 12

Oznamy

• Opravná písomka bude v piatok 8. novembra o 13:10 (čiže v čase piatkových doplnkových cvičení) v miestnosti F1-328. Prihlásiť sa na ňu treba najneskôr 24 hodín vopred.
• Doplnkové cvičenia v piatok 8. novembra nebudú; náhradné doplnkové cvičenia budú dnes a v pondelok 11. novembra o 11:30 v miestnosti M-217.

Zjednodušený model pamäte

Pamäť počítača si možno veľmi zjednodušene predstaviť ako konečnú postupnosť pamäťových miest, kde každé pamäťové miesto má kapacitu práve jeden byte. To možno znázorniť nasledujúcim obrázkom.

Každé pamäťové miesto má pridelené svoju adresu. Presný formát adries závisí od konkrétnej architektúry (môže napríklad ísť o 32-bitové alebo 64-bitové čísla), z pohľadu programátora však zvyčajne nie je dôležitý.

Premenným základných typov (ako napríklad int, char, double,...) sú počas vykonávania programu pridelené súvislé úseky pamäťových miest. Napríklad na architektúre s 32-bitovým – čiže 4-bytovým – typom int sa premenným tohto typu priraďujú úseky štyroch po sebe idúcich pamäťových miest. Adresou premennej potom rozumieme adresu prvého z týchto pamäťových miest. Táto situácia je znázornená na obrázku nižšie.

Poliam sa taktiež prideľujú súvislé úseky pamäte. Pre pole dĺžky N pozostávajúce z prvkov typu T sa pritom vyhradí N po sebe idúcich pamäťových úsekov, kde každý z nich postačuje práve na uchovanie jednej hodnoty typu T. Napríklad poľu a dĺžky N prvkov typu int sa na architektúre s 32-bitovým (4-bytovým) typom int pridelí súvislý úsek 4*N pamäťových miest tak, ako na nasledujúcom obrázku.

Smerníky

Smerník (niekde tiež ukazovateľ, angl. pointer) je premenná, ktorej hodnotou je pamäťová adresa. Napríklad na nasledujúcom obrázku je na adrese [adresa 2] uložená premenná typu int, ktorej hodnota je 12345. Na adrese [adresa 1] je uložený smerník, ktorého hodnota je [adresa 2] – hovoríme, že smerník ukazuje na pamäťovú adresu [adresa 2].

Definovanie smerníka

V C++ sa smerník ukazujúci na „pamäťový objekt” typu T definuje takto:

T *p;

Napríklad teda môžeme písať:

int *p1;    // smernik p1 na int
char *p2;   // smernik p2 na char
double *p3; // smernik p3 na double

// ...

Smerníky ukazujúce na „pamäťové objekty” rôznych typov sú takisto rôznych typov. Vo všeobecnosti nemožno realizovať priradenia medzi smerníkmi rôznych typov (nedôjde k automatickému pretypovaniu).

int *p1;
int *p2;
double *p3;

p1 = p2;   // korektne priradenie
p3 = p1;   // chyba, lebo p3 a p1 su smerniky roznych typov

Bez ohľadu na typ smerníka je jeho hodnotou vždy len pamäťová adresa, a teda sa ich práve popísané správanie môže zdať na prvý pohľad zvláštnym. Smerníky rôznych typov sa však, ako onedlho uvidíme, v určitých situáciách môžu „správať” rozdielne.

Operátor & (adresa)

Operátor & poskytuje azda najjednoduchší spôsob, ako získať zmysluplný smerník. Adresu premennej x nejakého základného typu (ako napríklad int, char,...) získame tak, že napíšeme &x – túto adresu potom možno priradiť do smerníka.

Nasledujúci program vytvorí celočíselnú premennú n, ktorej adresu priradí do smerníka p.

int main(void) {
    int n = 12345;
    int *p;
    p = &n;

    return 0;
}

Stav pamäte tesne pred skončením vykonávania tohto programu je znázornený na nasledujúcom obrázku.

Rovnakým spôsobom možno operátor & aplikovať aj na prvky poľa (t.j. napríklad &a[2] je adresa druhého – resp. tretieho – prvku poľa a).

Operátor & nemožno aplikovať na konštanty (ako napríklad 3.14 alebo 'c'), ani na výrazy (ako napríklad n+2).

    int n = 0;
    int a[5] = {1, 2, 3, 4, 5};
    int *p;

    p = &n;     // korektne priradenie
    p = &a[2];  // korektne priradenie
    p = &(n+1); // chyba (vyraz nema adresu)
    p = &42;    // chyba (konstanta 42 nema adresu)
    p = &a;     // chyba (a nie je typu int)

Operátor * (dereferencia)

Kľúčovým operátorom na smerníkoch je tzv. dereferencia, ktorá sa realizuje operátorom *. Ak p je smerník, možno pomocou zápisu *p pristúpiť k údajom na adrese reprezentovanej smerníkom p. Tieto údaje potom možno aj meniť, t. j. *p môže vystupovať napríklad aj na ľavej strane priradenia. To demonštrujeme na drobnom rozšírení predchádzajúceho príkladu.

#include <iostream>
using namespace std;

int main(void) {
    int n = 12345;
    int *p;       

    p = &n;              // smernik p odteraz ukazuje na adresu premennej n
    cout << *p << endl;  // vypise hodnotu uchovavanu na adrese p == &n, t. j. 12345
    *p = 9;              // hodnota uchovavana na adrese p == &n sa zmeni na 9; preto uz aj n == 9 
    cout << n << endl;   // vypise hodnotu premennej n, t. j. 9
    (*p)++;              // hodnota uchovavana na adrese p == &n sa zmeni na 10; preto uz aj n == 10 
    cout << n << endl;   // vypise hodnotu premennej n, t. j. 10
    n = 42;
    cout << *p << endl;  // vypise hodnotu uchovavanu na adrese p == &n, t. j. 42

    return 0;
}

Operátor dereferencie vysvetľuje aj spôsob, ktorým sa smerníky deklarujú. Riadok

int *p;

deklarujúci smerník na int totiž treba chápať takto: ak vezmeme smerník p a aplikujeme na neho operátor *, získame hodnotu typu int. Takáto interpretácia sa ukáže byť veľmi užitočnou pri komplikovanejších deklaráciách so smerníkmi.

Smerník NULL

Dôležitým špeciálnym prípadom smerníka je konštanta NULL reprezentujúca smerník, ktorý nikam neukazuje.

• Je definovaná vo viacerých štandardných knižniciach, ako napríklad cstdlib alebo iostream.
• Možno ju priradiť do smerníka ľubovoľného typu.

Smerník ako parameter funkcie

V „čistom C” okrem iného nie je možné predávať parametre funkcií referenciou. Rovnaký efekt však možno docieliť predávaním hodnotou tak, že sa ako hodnota pošle smerník. To demonštrujeme pomocou nasledujúcej „smerníkovej” verzie funkcie realizujúcej výmenu hodnôt dvoch premenných.

#include <iostream>
using namespace std;

void swap(int *px, int *py) {                      // parametre su smerniky (adresy v pamati)
    int tmp = *px;                                 // hodnotu na adrese px ulozime do tmp
    *px = *py;                                     // hodnotu na adrese px zmenime na hodnotu na adrese py
    *py = tmp;                                     // hodnotu na adrese py zmenime na tmp
}

int main(void) {
    int x,y;
    cout << "Zadaj x,y: ";
    cin >> x >> y;
    swap(&x, &y);                                  // ako parametre posleme adresy premennych x,y
    cout << "x = " << x << ", y = " << y << endl;

    return 0;
}

Poznať uvedenú alternatívu k predávaniu parametrov referenciou môže byť užitočné aj pri práci v C++, keďže ju často využívajú rôzne knižničné funkcie.

Dynamická alokácia a dealokácia pamäte

Doteraz sme videli:

• Globálne premenné, ktoré majú vopred známu veľkosť a vyhradenú pamäť.
• Lokálne premenné, ktoré majú vopred známu veľkosť, ale pamäť sa im prideľuje až pri volaní funkcie na tzv. zásobníku volaní funkcií (angl. call stack).

Program si ale počas behu môže podľa potreby vyhradiť aj ďalšiu pamäť:

• Používa sa na to operátor new.
• Pamäť sa vyhradí v oblasti zvanej halda (angl. heap).
• Nepotrebnú pamäť vyhradenú takýmto spôsobom je dobrým zvykom uvoľniť pomocou operátora delete.

#include <iostream>
using namespace std;

int main(void) {
    int *p;        

    p = new int;   // new int vyhradi usek pamate postacujuci na uchovanie prave jednej hodnoty typu int
                   // adresa tohto novovytvoreneho useku pamate sa ulozi do smernika p   
    *p = 50;       // do alokovanej pamate sa ulozi hodnota 50 
    cout << *p << endl;  
    delete p;      // uvolnenie alokovanej pamate

    return 0;
}

Smerníky a polia

Smerníky a polia spolu veľmi úzko súvisia. Operátor [ ] je totiž v prvom rade definovaný na smerníkoch. Nech p je smerník definovaný ako

T *p;

kde T označuje nejaký typ. V takom prípade:

• Zápis p[0] vyjadruje to isté ako *p – ide o hodnotu typu T uloženú na adrese reprezentovanej smerníkom p.
• Zápis p[i] vyjadruje hodnotu typu T uloženú na i-tom pamäťovom úseku (o veľkosti postačujúcej práve na uloženie hodnoty typu T) za úsekom s adresou reprezentovanou smerníkom p. Hoci tento zápis funguje vždy, je dôležité používať ho iba vtedy, keď vieme, čo na danej adrese je.

Táto situácia je znázornená na nasledujúcom obrázku.

Pole a prvkov typu T definované ako

T a[N];

je potom konštantný smerník na prvok typu T (prvý – t. j. vlastne nultý – prvok poľa). Konštantným je preto, lebo adresa prvého prvku takto definovaného poľa je počas behu programu fixná a nemôže sa meniť.

Každé pole je teda zároveň aj smerníkom na svoj prvý prvok. Každé pole typu T tak možno priradiť do smerníka na prvok typu T (avšak nie naopak, lebo polia sú konštantné smerníky). Zápis int a[] pre pole ľubovoľnej veľkosti predávané ako parameter funkcie je navyše len rozdielnym zápisom pre int *a. Korektný je tak napríklad aj nasledujúci program.

#include <iostream>
using namespace std;

const int maxN = 1000;

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

void vypisPoleOdzadu(int *a, int odkial) {
    for (int i = odkial; i >= 0; i--) {
        cout << a[i] << " ";
    }
    cout << endl;
}

int main(void) {
    int N;
    int a[maxN];
    int *b;
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    for (int i = 0; i <= N-1; i++) {
        cout << "Zadaj cislo " << i+1 << ": ";
        cin >> a[i];
    }
    
    vypisPole(a,N-1); 
    b = a;
    vypisPole(b,N-1);
    
    vypisPoleOdzadu(a,N-1);
    
    return 0;
}

Dynamické alokovanie poľa

Operátorom new možno alokovať aj pole zadanej dĺžky N (t. j. súvislý úsek pamäte postačujúci na uchovanie práve N hodnôt daného typu). Napríklad príkaz

int *p = new int[10];

vyhradí pamäť postačujúcu práve na uchovanie desiatich celých čísel – čiže vlastne pole veľkosti 10. Z pozorovaní učinených vyššie vyplýva, že smerník p je potom možné používať úplne rovnakým spôsobom, ako polia:

• Hodnota p[0] je tá istá ako *p.
• Hodnota p[i] pre i = 0,...,9 reprezentuje hodnotu i-teho prvku poľa.

Vytvorené a už nepotrebné pole je dobrým zvykom uvoľniť operátorom delete[] (hranaté zátvorky na konci sú naozaj podstatné; program používajúci na pole iba operátor delete síce skompiluje, ale jeho správanie je nedefinované).

Takúto dynamickú alokáciu polí možno využiť napríklad na vytvorenie poľa o používateľom zadanej veľkosti tak, ako v nasledujúcom ukážkovom programe.

#include <iostream>
using namespace std;

int main(void) {
    cout << "Zadaj pocet cisel: ";
    int N;
    cin >> N;
    int *a = new int[N];
    
    for (int i = 0; i <= N-1; i++) {
        cout << "Zadaj cislo " << i+1 << ": ";
        cin >> a[i];
    }
    for (int i = N-1; i >= 0; i--) {
        cout << a[i] << " ";
    }
    delete[] a;
    cout << endl;

    return 0;   
}

Poznámka: Niektoré kompilátory (ako napríklad gcc) umožňujú vytvoriť pole o používateľom zadanej veľkosti aj jednoduchším spôsobom, keďže akceptujú deklarácie typu int a[N];, kde N môže byť aj premenná, ktorej hodnota už bola načítaná príkazom cin >> N;. Nemusí to ale fungovať vždy – odporúčané je používať radšej dynamickú alokáciu poľa tak, ako v príklade vyššie.

Aplikácia smerníkov: dynamické polia

Asi najvýraznejším nedostatkom polí je ich fixná veľkosť. Počas behu programu totiž môže vzniknúť potreba pridávať ďalšie a ďalšie prvky, ktoré sa postupne do poľa nemusia vojsť. Riešenie tejto situácie nadhodnotením veľkosti poľa nie je ideálne, keďže sa tak plytvá pamäťou.

Ako riešenie tohto problému teraz naprogramujeme tzv. dynamické pole, ktoré mení svoju veľkosť s tým, ako sa doň pridávajú prvky. Základná idea pritom bude nasledovná:

• Zakaždým, keď sa pole plne naplní, alokujeme preň nový a väčší pamäťový úsek, kam celé pole presunieme. Starý pamäťový úsek z pamäte uvoľníme.
• Keďže kopírovanie poľa do novoalokovaného pamäťového úseku bude mierne neefektívne (bude potrebné prejsť cez celé pole), budeme sa snažiť vyvarovať toho, aby sme ho museli realizovať zakaždým, keď do poľa pridáme nejaký prvok. Na druhej strane však nechceme alokovať zbytočne veľké úseky pamäte. Rozumným kompromisom sa javí byť zdvojnásobenie veľkosti alokovaného úseku zakaždým, keď sa pole naplní.
• V štandardných C++ knižniciach je definovaná dátová štruktúra vector, ktorá sa správa podobne. My teraz vo svojej podstate implementujeme zjednodušenú verziu tejto štruktúry.

Pre jednoduchosť napíšeme iba verziu dynamického poľa pre celé čísla (typ int). Analogicky by sme však mohli postupovať aj pre iné typy.

Dynamické pole celých čísel budeme reprezentovať ako štruktúru typu dynArray, ktorá bude pozostávať z nasledujúcich troch zložiek:

• Zo smerníku p ukazujúceho na prvý prvok poľa (čiže vlastne pole samotné).
• Z celočíselnej premennej size, v ktorej bude uchovávaná veľkosť alokovanej pamäte pre pole p.
• Z celočíselnej premennej length, v ktorej bude uchovávaný počet prvkov doposiaľ pridaných do poľa.

Napíšeme potom niekoľko funkcií, pomocou ktorých budeme s dynamickými poľami manipulovať.

• Funkcia void init(dynArray &a) inicializuje dynamické pole a, pričom mu alokuje nejaký rozumne malý objem pamäte (ten v našej implementácii bude postačovať na uchovanie práve dvoch prvkov typu int).
• Funkcia void add(dynArray &a, int x) pridá na koniec dynamického poľa a prvok s hodnotou x. V prípade potreby ešte predtým realokuje pamäť.
• Funkcia int get(dynArray a, int index) vráti prvok dynamického poľa a na pozícii index. V prípade, že index nereprezentuje korektnú pozíciu prvku poľa (teda je menší ako 0 alebo väčší, než a.length - 1), ukončí vykonávanie programu pomocou assert.
• Funkcia void set(dynArray &a, int index, int x) nastaví prvok dynamického poľa na pozícii index na hodnotou x. Ak index nereprezentuje korektnú pozíciu prvku poľa, ukončí vykonávanie programu pomocou assert.
• Funkcia int length(dynArray a) vráti počet prvkov doposiaľ uložených do dynamického poľa a.
• Funkcia void destroy(dynArray &a) zlikviduje dynamické pole a (uvoľní pamäť).

Bez ohľadu na implementáciu samotného dynamického poľa už teda vieme napísať kostru programu, ktorý ho využíva:

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

struct dynArray {
// ...
};

void init(dynArray &a) {
// ...
}

void add(dynArray &a, int x) {
// ...
}

int get(dynArray &a, int index) {
// ...
} 

void set(dynArray &a, int index, int x) {
// ...
}

int length(dynArray &a) {
// ...
}

void destroy(dynArray &a) {
// ...
}

int main(void) {
    dynArray a;
    init(a);
    
    int k;
    cin >> k;
    while (k >= 0) {                 
        add(a,k);                    // pridava prvky do pola, kym su nezaporne
        cin >> k;    
    }
    for (int i = length(a) - 1; i >= 0; i--) {
        cout << get(a,i) << " ";     // vypise prvky pola od konca
    }
    cout << endl;
    set(a,0,42);
    cout << get(a,0) << endl;

    destroy(a);

    return 0;    
}

Môžeme teraz prejsť k samotnej implementácii dynamického poľa:

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

/* Dynamicke pole celych cisel */

struct dynArray {
    int *p;                   // smernik na prvy prvok pola
    int size;                 // velkost alokovaneho pola
    int length;               // pocet prvkov pridanych do pola
};

void init(dynArray &a) {
/* Inicializuje dynamicke pole, pricom na zaciatok pren alokuje pole velkosti 2 */
    a.size = 2;
    a.length = 0;
    a.p = new int[a.size];
}

void add(dynArray &a, int x) {
/* Prida na koniec dynamickeho pola prvok x a v pripade potreby realokuje pole */
    if (a.length == a.size) {                // ak uz sa x do pola nevojde
        a.size *= 2;
        int *newp = new int[a.size];         // alokuje pole dvojnasobnej velkosti
        for (int i = 0; i <= a.length - 1; i++) { 
            newp[i] = a.p[i];                // prekopiruje stare pole do noveho
        }
        delete[] a.p;                        // zmaze stare pole
        a.p = newp;                          // a.p odteraz ukazuje na nove pole
    }
    a.p[a.length] = x;                       // ulozi x na koniec pola
    a.length++;                              // zvysi pocet prvkov ulozenych v poli 
}

int get(dynArray &a, int index) {
/* Vrati prvok dynamickeho pola a na pozicii index (ak ide o korektnu poziciu)*/
    assert(index >= 0 && index <= a.length - 1);
    return a.p[index];
} 

void set(dynArray &a, int index, int x) {
/* Nastavi prvok dynamickeho pola a na pozicii index na hodnotu x (ak ide o korektnu poziciu)*/
    assert(index >= 0 && index <= a.length - 1);
    a.p[index] = x;
}

int length(dynArray &a) {
/* Vrati pocet prvkov ulozenych v dynamickom poli a */
    return a.length;
}

void destroy(dynArray &a) {
/* Zlikviduje dynamicke pole a (uvolni alokovanu pamat) */
    delete[] a.p;
}

int main(void) {
    dynArray a;
    init(a);
 
    int k;
    cin >> k;
    while (k >= 0) {                 
        add(a,k);                    // pridava prvky do pola, kym su nezaporne
        cin >> k;    
    }
    for (int i = length(a) - 1; i >= 0; i--) {
        cout << get(a,i) << " ";     // vypise prvky pola od konca
    }
    cout << endl;
    set(a,0,42);
    cout << get(a,0) << endl;
 
    destroy(a);

    return 0;    
}

Smerníková aritmetika

Na smerníkoch možno vykonávať určité operácie, súhrn ktorých býva honosne nazývaný smerníkovou aritmetikou. Nech p, p1, p2 sú smerníky definované ako

T *p;
T *p1;
T *p2;

kde T označuje nejaký typ. Nech n je typu int. Potom:

• p + n označuje smerník na n-tý pamäťový úsek (postačujúci práve na uchovanie hodnoty typu T) za adresou p.
  • Napríklad p+n je to isté ako &p[n] a *(p+n) je to isté ako p[n].
  • p++ je skratkou pre p = p+1, ...
• Operátor [ ] je teda nadbytočný – p[n] je len skratkou pre často používaný výraz *(p+n).
• p - n označuje smerník na n-tý pamäťový úsek (postačujúci práve na uchovanie hodnoty typu T) pred adresou p.
• p1 - p2 je celé číslo k také, že p1 == p2 + k. Zmysluplný výsledok možno očakávať len vtedy, keď p1 a p2 sú adresami prvkov v tom istom poli (v jedinom súvislom kuse pamäte).
• Smerníky tiež možno prirodzene porovnávať relačnými operátormi ==, <, >, <=, >=, !=. Výsledok je zmysluplný opäť len vtedy, keď p1 a p2 sú adresami prvkov v tom istom poli.

Program, ktorý najprv načíta pole a následne prvky tohto poľa vypíše od konca, tak možno napísať napríklad aj takto:

#include <iostream>
using namespace std;

const int maxN = 1000;

int main(void) {
    int a[maxN];
    int N;
    cout << "Zadaj pocet cisel: ";
    cin >> N;
    for (int i = 0; i <= N-1; i++) {
        cout << "Zadaj cislo " << i + 1 << ": ";
        cin >> *(a + i);    
    }
    for (int i = N-1; i >= 0; i--) {
        cout << *(a + i) << " ";
    }
    cout << endl;
    return 0;
}

Ladenie programov so smerníkmi

• Smerníky môžu byť nepríjemným zdrojom chýb, keďže kompilátor nekontroluje, či sú používané správne.
• Napríklad možno čítať aj zapisovať mimo alokovanej pamäte.
• S odchytávaním takýchto chýb môžu pomôcť automatizované nástroje, ako napríklad Valgrind (pre Linux) alebo Dr. Memory (pre Windows aj Linux).
• Návod na prácu s programom valgrind

Prednáška 13

Oznamy

• Opravná písomka bude v piatok 8. novembra o 13:10 (čiže v čase piatkových doplnkových cvičení) v miestnosti F1-328. Prihlásiť sa na ňu treba najneskôr 24 hodín vopred.
• Doplnkové cvičenia v piatok 8. novembra nebudú; v pondelok 11. novembra o 11:30 v miestnosti M-217 budú náhradné doplnkové cvičenia.

Deklarácie so smerníkmi a poľami

Na dnešnej prednáške budeme kombinovať smerníky a polia – budeme tak písať výrazy obsahujúce súčasne operátor [ ] pre prístup k danému prvku poľa a dereferenčný operátor * pre smerníky. Na správnu interpretáciu takýchto výrazov je potrebné vedieť nasledujúce:

• Operátor [ ] má vyššiu prioritu ako *. Napríklad zápis *a[10] teda treba chápať ako *(a[10]). To znamená, že vezmeme pole a, pozrieme sa na jeho desiaty prvok a následne na tento desiaty prvok aplikujeme derefernciu. Prvky poľa a sú teda (v prípade, že robíme niečo zmysluplné) smerníky. Naopak (*p)[10] znamená nasledovné: vezmeme p, aplikujeme dereferenciu (p je teda smerník), ktorej výsledkom je pole a pozrieme sa na desiaty prvok tohto poľa.
• Operátor [ ] je zľava asociatívny a operátor * je sprava asociatívny. To znamená, že napríklad a[2][3] je to isté ako (a[2])[3] a **p je to isté ako *(*p).

Napríklad deklaráciu

int *a[10]; // t. j. *(a[10])

teraz treba chápať takto: ak vezmeme a, pozrieme sa na niektorý z desiatich prvkov tohto poľa a nakoniec aplikujeme dereferenciu, dostaneme hodnotu typu int. Zadeklarovali sme teda desaťprvkové pole smerníkov na int. Rovnako možno intepretovať aj nasledujúce deklarácie:

int **a;         // a je smernik na smernik na int; kazde pole smernikov na int tak mozno priradit do a (ale nie opacne)
int (*a)[10];    // a je smernik na pole desiatich celych cisel
int *(*(a[10])); // a je desatprvkove pole smernikov na smerniky na int
int **a[10];     // to iste, ako na predchadzajucom riadku

Dvojrozmerné polia

Doposiaľ sme pracovali iba s jednorozmernými poľami. Často je však potrebné pracovať s viacrozmernými údajmi – tými sú napríklad tabuľky, matice, atď. Na tejto prednáške sa zameriame na dvojrozmerný prípad, potreba ktorého vyvstáva najčastejšie.

Najjednoduchší – hoci väčšinou nepraktický – spôsob práce s takýmito údajmi poskytuje priamo C++ v podobe takzvaných viacrozmerných polí. Prácu s dvojrozmernými poľami si teraz v stručnosti ukážeme. Ide o jednoduché rozšírenie jednorozmerných polí – akurát namiesto i-teho prvku a[i] pristupujeme k prvkom a[i][j] v i-tom riadku a j-tom stĺpci dvojrozmerného poľa.

#include <iostream>
using namespace std;

int main(void) {
    /* Vytvorime pole s dvoma riadkami a piatimi stlpcami a rovno ho aj inicializujeme: */ 
    int a[2][5] = {{1,2,3,4,5},{6,7,8,9,10}}; 

    /* Vypiseme pole ako tabulku: */
    for (int i = 0; i <= 1; i++) {
        for (int j = 0; j <= 4; j++) {
            cout << a[i][j] << " ";
        }
        cout << endl;
    }

    return 0;
}

Dvojrozmerné pole o m riadkoch a n stĺpcoch sa v pamäti reprezentuje ako jediný súvislý úsek, v ktorom idú za sebou jednotlivé riadky reprezentované ako jednorozmerné polia. To je znázornené na nasledujúcom obrázku.

Z tejto reprezentácie ale vyplýva, že typ dvojrozmerného poľa je inherentne previazaný s dĺžkou jednotlivých riadkov (t. j. s počtom stĺpcov). To sa ukazuje byť nepraktické napríklad pri predávaní dvojrozmerných polí ako parametrov pre funkcie, v hlavičkách ktorých je nutné tento počet stĺpcov zadať:

...

void f1(int a[2][5]) {
    ...
}

void f2(int a[][5]) {
    ...
}

void f3(int (*a)[5]) {
    ...
}

void f4(int a[][]) {   // uz samotny tento zapis vyusti v chybu
    ...
}

int main(void) {
    int a[2][5];
    
    ...
   
    f1(a); // OK
    f2(a); // OK
    f3(a); // OK
    f4(a); // nefunguje

    ...
}

Budeme preto hľadať pohodlnejší spôsob práce s dvojrozmernými údajmi.

Polia smerníkov

Omnoho pohodlnejšou alternatívou k dvojrozmerným poliam sú polia smerníkov. Dvojrozmerné dáta tu uchovávame prostredníctvom poľa, i-ty prvok ktorého je smerníkom ukazujúcim na prvý – t. j. vlastne nultý – prvok i-teho riadku. Pre každý riadok potom môžeme naalokovať samostatné pole pre jeho prvky. Má to okrem iného tú výhodu, že jednotlivé riadky nemusia byť rovnako dlhé. Zatiaľ si však len ukážme spôsob, ako vytvoriť pole smerníkov reprezentujúce obdĺžnikovú tabuľku typu m krát n; to bude v pamäti reprezentované podobne, ako na nasledujúcom obrázku.

Nasledujúci program vytvorí pole smerníkov, ktoré reprezentuje obdĺžnikovú tabuľku o m krát n celých číslach, načíta do nej prvky zo vstupu a nakoniec na výstup vypíše aritmetické priemery hodnôt v jednotlivých jej stĺpcoch.

#include <iostream>
using namespace std;

const int max_m = 200;

int main(void) {
    int m,n;
    int *a[max_m];
    cout << "Zadaj pocet riadkov: ";
    cin >> m;
    cout << "Zadaj pocet stlpcov: ";
    cin >> n;
    
    /* Alokuj jednotlive riadky: */
    for (int i = 0; i <= m-1; i++) {
        a[i] = new int[n];           // a[i] je smernik na i-ty riadok
    }
    
    /* Nacitanie prvkov tabulky: */
    cout << "Zadaj cisla tabulky:" << endl;
    for (int i = 0; i <= m-1; i++) {
        for (int j = 0; j <= n-1; j++) {
            cin >> a[i][j];          // nacitaj j-ty prvok i-teho riadku 
        }
    }
    
    /* Spocitaj a vypis priemery hodnot v jednotlivych stlpcoch: */
    for (int j = 0; j <= n-1; j++) {
        int sum = 0;
        for (int i = 0; i <= m-1; i++) {
            sum += a[i][j];
        }
        cout << "Priemer hodnot v stlpci " << j + 1 << " je " << (sum * 1.0)/m << endl;
    } 

    /* Uvolnenie pamate: */
    for (int i = 0; i <= m-1; i++) {
        delete[] a[i];
    }

    return 0;
}

Dynamicky alokované polia smerníkov

Aj samotné polia smerníkov je možné alokovať dynamicky, čo umožňuje počas behu nastaviť nielen veľkosť jednotlivých riadkov, ale aj ich počet. Príklad s priemermi jednotlivých stĺpcov tak vieme prepísať napríklad nasledovne:

#include <iostream>
using namespace std;

int main(void) {
    int m,n;
    int **a;
    cout << "Zadaj pocet riadkov: ";
    cin >> m;
    cout << "Zadaj pocet stlpcov: ";
    cin >> n;
    
    /* Alokuj pole smernikov na riadky: */
    a = new int *[m];
    
    /* Alokuj jednotlive riadky: */
    for (int i = 0; i <= m-1; i++) {
        a[i] = new int[n];           // a[i] je smernik na i-ty riadok
    }
    
    /* Nacitanie prvkov tabulky: */
    cout << "Zadaj cisla tabulky:" << endl;
    for (int i = 0; i <= m-1; i++) {
        for (int j = 0; j <= n-1; j++) {
            cin >> a[i][j];          // nacitaj j-ty prvok i-teho riadku 
        }
    }
    
    /* Spocitaj a vypis priemery hodnot v jednotlivych stlpcoch: */
    for (int j = 0; j <= n-1; j++) {
        int sum = 0;
        for (int i = 0; i <= m-1; i++) {
            sum += a[i][j];
        }
        cout << "Priemer hodnot v stlpci " << j + 1 << " je " << (sum * 1.0)/m << endl;
    } 
    
    /* Uvolnenie pamate: */
    for (int i = 0; i <= m-1; i++) {
        delete[] a[i];
    }
    delete[] a;
    
    return 0;
}

Príklad: výšková mapa

Pokračujme ukážkou o niečo väčšieho programu využívajúceho dynamicky alokované polia smerníkov. Ten bude v obdĺžnikovej tabuľke celých čísel uchovávať výškovú mapu nejakého územia, v ktorom nadmorská výška nadobúda hodnoty medzi 0 a 2000 metrami nad morom.

Program na vstupe najprv dostane dvojicu prirodzených čísel m a n. Výškovou mapou potom bude obdĺžnik pozostávajúci z m krát n štvorčekov, kde každý zo štvorčekov bude mať danú nejakú nadmorskú výšku od 0 po 2000 metrov nad morom (nadmorská výška 0 znamená more a kladná nadmorská výška znamená pevninu). Následne program postupne prečíta zo vstupu nadmorské výšky všetkých štvorčekov.

Takto zadanú mapu program vykreslí pomocou knižnice SVGdraw, pričom každý štvorček dostane určitú farbu podľa svojej nadmorskej výšky. Následne zavolá funkciu najvyssiVrch, ktorá nájde najvyšší bod (resp. jeden z najvyšších bodov) vykresľovaného územia a v mape ho zvýrazní rámikom.

Príklad vstupu a výstupu:

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

Samotný program:

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

/* velkost stvorceka mapy v pixeloch */
const int stvorcek = 15;

int **vytvorMapu(int m, int n) {
    /* Vytvori a vrati na vystupe mapu (obdlznikovu tabulku) s m riadkami a n stlpcami. */
    int **a;
    a = new int *[m];
    for (int i = 0; i <= m-1; i++) {
        a[i] = new int[n];
    }
    return a;
}

void zmazMapu(int m, int n, int **a) {
    /* Uvolni z pamate mapu s m riadkami a n stlpcami.
       Parameter n je nadbytocny, ale mohol by sa zist, keby napriklad 
       bolo treba z pamate uvolnovat aj jednotlive prvky matice a. */
    for (int i = 0; i <= m-1; i++) {
        delete[] a[i];
    }
    delete[] a;
}

void nacitajMapu(int m, int n, int **a) {
    /* Nacita hodnoty (nadmorske vysky) do uz vytvorenej mapy velkosti m krat n. */
    for (int i = 0; i <= m-1; i++) {
        for (int j = 0; j <= n-1; j++) {
            cin >> a[i][j];
        }
    }
}

void farba(SVGdraw &drawing, int r, int g, int b) {
    /* Nastavi farbu ciary aj vyplne na dane hodnoty. */
    drawing.setLineColor(r, g, b);
    drawing.setFillColor(r, g, b);
}

void vykresliMapu(int m, int n, int **a, SVGdraw &drawing) {
    /* Ofarbi jednotlive stvorceky mapy podla ich nadmorskej vysky:
     * modra -- more (nadmorska vyska 0)
     * zelena -- niziny (nadmorska vyska 1,...,200)
     * hneda -- "pohoria" (nadmorska vyska 200,...,2000) */
    for (int i = 0; i <= m-1; i++) {
        for (int j = 0; j <= n-1; 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) / 1800.0;
                farba(drawing, 255 - x * 150, 255 - x * 200, 0);
            }
            /* Vykreslenie stvorceka; POZOR: vymena suradnic */
            drawing.drawRectangle(j * stvorcek, i * stvorcek, stvorcek, stvorcek);
        }
    }
}

void najvyssiVrch(int m, int n, int **a, int &riadok, int &stlpec) {
    /* Najde v mape a o rozmeroch m krat n stvorcek s najvyssou nadmorskou vyskou
       a jeho suradnice ulozi do premennych riadok resp. stlpec. */
    riadok = 0;
    stlpec = 0;
    for (int i = 0; i <= m-1; i++) {
        for (int j = 0; j <= n-1; j++) {
            if (a[i][j] > a[riadok][stlpec]) {
                riadok = i;
                stlpec = j;
            }
        }
    }
}

int main(void) {
    /* nacitaj rozmery matice */
    int m, n;
    cin >> m >> n;

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

    nacitajMapu(m, n, a);

    /* zobraz maticu */
    SVGdraw drawing(n * stvorcek, m * stvorcek, "mapa.svg"); // POZOR: vymena suradnic
    vykresliMapu(m, n, a, drawing);

    /* najdi najvyssi vrch a zvyrazni ho stvorcekom */
    int riadok, stlpec;
    najvyssiVrch(m, n, a, riadok, stlpec);

    drawing.setLineColor("black");
    drawing.setLineWidth(3);
    drawing.setNoFill();
    drawing.drawRectangle(stlpec * stvorcek, riadok * stvorcek, stvorcek, stvorcek); // POZOR: vymena suradnic

    /* ukonci vykreslovanie */
    drawing.finish();

    /* uvolni pamat matice */
    zmazMapu(m, n, a);
    
    return 0;
}

Polia reťazcov

Každý reťazec je pole znakov, ktoré možno interpretovať aj ako smerník na char. Pole reťazcov teda možno implementovať ako pole smerníkov na char. Keďže sa vo väčšine aplikácií môžu vyskytovať reťazce rôznych dĺžok, ukazuje sa tu byť užitočná vlastnosť polí smerníkov spomínaná vyššie – jednotlivé ich riadky môžu mať rôzne dĺžky.

Nasledujúci jednoduchý program je ukážkou použitia takto implementovaných polí reťazcov. Zo vstupu postupne načítava riadky, až kým je zadaný prázdny riadok. Tie postupne ukladá do poľa. Na záver sa všetky tieto reťazce vypíšu na výstup, oddelené medzerami.

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

const int maxN = 1000;
const int maxRiadok = 1000;

int main(void) {
    char *a[maxN];
    char riadok[maxRiadok];
    int N = 0;
    while (N <= maxN-1) {                 
        cin.getline(riadok, maxRiadok);      // nacitame jeden riadok zo vstupu
        if (strcmp(riadok, "") == 0) {       // v pripade prazdneho riadku ukoncime nacitavanie
            break;
        }
        /* 
           Alokujeme pamat pre N-ty retazec pola a.
           (Musi byt o 1 vacsia, nez jeho dlzka -- dovodom je znak \0 na konci).
        */
        a[N] = new char[strlen(riadok) + 1]; 
        strcpy(a[N], riadok);
        N++;
    }
    // Vypiseme jednotlive riadky oddelene medzerami:
    for (int i = 0; i <= N-1; i++) {
        cout << a[i] << " ";
    }
    // Uvolnime pamat:
    for (int i = 0; i <= N-1; i++) {
        delete[] a[i];
    }

    return 0;
}

Cvičenie: prerobte tento program tak, aby namiesto poľa a fixnej veľkosti maxN používal dynamické pole.

Zadávanie argumentov programu z príkazového riadku

Polia reťazcov umožňujú okrem iného aj napísať program, ktorý dostane a spracuje jeden alebo viacero argumentov z príkazového riadku a na základe nich prípadne „upraví svoje správanie”. Príkladom programu využívajúcim túto funkcionalitu je aj samotný kompilátor g++. Jeho najjednoduchšie volanie

g++ program.cpp

obsahuje okrem názvu programu g++ aj argument program.cpp – ten dáva kompilátoru informáciu o tom, ktorý zdrojový súbor má kompilovať.

Na písanie programov umožňujúcich spracovanie takýchto argumentov je potrebné využiť „jemne pokročilejšiu” verziu funkcie main s hlavičkou

int main(int argc, char **argv)

– tú automaticky generujú viaceré pokročilejšie textové editory alebo IDE (napríklad NetBeans). Význam parametrov argc a argv je nasledovný:

• argv je pole reťazcov (resp. pole smerníkov na char) a argc je počet reťazcov v tomto poli.
• Reťazec argv[0] je vždy názov programu.
• Reťazce argv[1],...,argv[argc-1] sú jednotlivé argumenty.

Nasledujúci jednoduchý program postupne vypíše všetky argumenty, ktoré dostal z príkazového riadku.

#include <iostream>
using namespace std;

int main(int argc, char **argv) {
    for (int i = 0; i <= argc-1; i++) {
        cout << argv[i] << endl;
    }
    return 0;
}

Prednáška 14

Oznamy

• Dnes do 22:00 treba odovzdať druhú domácu úlohu.
• Druhá písomka bude v stredu 20. novembra o 18:10 v miestnosti A.

Ešte k smerníkom

Opakovanie z minulých dvoch prednášok

Základy práce so smerníkmi:

int a = 7;         // premenna typu int 
int *b = NULL;     // smernik na int 
b = &a;            // b obsahuje adresu premennej a 
*b = 8;            // v premennej a je teraz 8 
a = (*b)+1;        // v premennej a je teraz 9

Smerníky a polia:

int a[3];           // a je vlastne konstantny smernik na prvy prvok pola
int *b = a;         // mozeme ho priradit do ineho smernika (opacne to nejde)
*b = 3;            
b[1] = 4;          
a[2] = 5;           // pole a teraz obsahuje cisla 3,4,5  
for (int i=0; i<3; i++){
   cout << *(a+i) << "=" << a[i] << endl;   // rozne zapisy toho isteho
}
b = new int[a[1]];  // b teraz ukazuje na nove pole dlzky 4
delete[] b;         // uvolnenie pamate alokovanej pre nove pole

Smerníky a struct

Smerník môže ukazovať aj na struct. Operátory . (prístup k prvku štruktúry) a [] (prístup k prvku poľa) majú vyššiu prioritu ako operátory * (dereferencia smerníka) a & (adresa). Preto napríklad:

• Zápis *s.cokolvek je to isté ako *(s.cokolvek) a vyjadruje dereferenciu smerníka s.cokolvek.
• Zápis (*p).cokolvek vyjadruje prvok cokolvek štruktúry získanej dereferenciou smerníka p.
• Zvyčajne je potrebnejší zápis (*p).cokolvek; existuje preň preto skratka p->cokolvek.

Podobne (ako sme videli už minule):

• Zápis *a[10] je to isté ako *(a[10]) a vyjadruje dereferenciu smerníka, ktorý je desiatym prvkom poľa a.
• Zápis (*p)[10] vyjadruje desiaty prvok poľa, ktoré dostaneme dereferenciou smerníka p.

struct bod {
  int x, y;
};

// ...

bod b;             
b.x = 0;
b.y = 0;

// ...

bod *p;            // smernik na strukturu typu bod
p = &b;            // p ukazuje na bod b 
bod *p2 = new bod; // alokovanie noveho bodu 
(*p2).x = 20;      // bod, na ktory ukazuje p2, bude mat x-ovu suradnicu 20
p2->y = 10;        // bod, na ktory ukazuje p2, bude mat y-ovu suradnicu 10
delete p2;         // uvolnenie pamate

Dynamické množiny: úvod

Uvažujme nasledujúce dva „motivačné” príklady:

Príklad č. 1

Na fakulte sa dvere do niektorých miestností otvárajú priložením čipovej karty k čítačke. Jeden (asi nie úplne optimálny) prístup k implementácii takéhoto systému by mohol byť nasledovný:

• Každá karta má v sebe uložené identifikačné číslo.
• Čítačka má v pamäti zoznam identifikačných čísel oprávnených osôb (študenti, niektorí vyučujúci a pod.).
• Po priložení karty z nej čítačka prečíta číslo a zisťuje, či ho má vo svojom zozname.

Ako môže byť takýto prístupový systém naprogramovaný?

Príklad č. 2

Dispečing technicky zaostalej prepravnej spoločnosti s veľkým množstvom vozidiel má systém pracujúci nasledujúcim spôsobom:

• Pre každé vozidlo si pamätá, či je momentálne k dispozícii alebo nie.
• Vozidlá neustále menia svoj stav podľa toho, ako prichádzajú do resp. odchádzajú z vozovne.
• V prípade požiadavky na vozidlo sa vyberie niektoré, ktoré je momentálne k dispozícii.
• Výnimočne je potrebné pozvať niektorého vodiča k šéfovi na koberec; v takom prípade je potrebné pre konkrétne vozidlo zistiť, či je akurát k dispozícii.

Ako môže byť takýto systém implementovaný?

Dynamické množiny

V obidvoch horeuvedených príkladoch sa vyskytuje nejaká množina A. V prvom príklade môže ísť napríklad o osoby s oprávnením vstupu do miestnosti a v druhom príklade môže ísť o vozidlá, ktoré sú momentálne k dispozícii. Tieto množiny sa v čase menia – hovoríme preto o dynamických množinách. V obidvoch príkladoch pritom potrebujeme nasledujúce funkcie:

• Funkciu contains, ktorá pre daný prvok x zistí, či patrí do množiny A.
• Funkciu add, ktorá do množiny pridá nový prvok x.
• Funkciu remove, ktorá z množiny odoberie prvok x (ňou sa ale dnes zaoberať nebudeme).
• Niekedy sa môžu zísť aj iné operácie.

Ako dnes uvidíme, dynamickú množinu môžeme implementovať množstvom rôznych spôsobov. Program s dynamickými množinami pracujúci si ale vystačí s operáciami popísanými vyššie, bez ohľadu na ich implementáciu. Hovoríme, že dynamické množiny sú abstraktný dátový typ – hovorí totiž iba o „rozhraní”, ktoré má dátová štruktúra poskytovať používateľovi, nie o jej implementácii.

Obidva uvedené príklady sa líšia „kritickosťou” jednotlivých operácií:

• Pri prístupovom systéme často potrebujeme predovšetkým operáciu contains, ktorá sa vykoná pri každom priložení karty k čítačke. Operácie add a remove sa vykonávajú zriedkavejšie, pri aktualizácii zoznamu oprávnených osôb.
• V druhom príklade naopak často voláme operácie add a remove (a prípadne ešte nejakú ďalšiu operáciu, ktorá vráti ľubovoľný prvok množiny). Operáciu contains používame zriedkavejšie (pri volaní konkrétneho vodiča na koberec).

Dynamické množiny sa používajú aj v mnohých iných situáciách a – ako uvidíme – dajú sa implementovať rozličnými spôsobmi. Tieto implementácie sú typicky zamerané na jednu alebo niekoľko z poskytovaných operácií, ktoré sú pri nej vykonávané efektívne. Pri rozličných aplikáciách je teda často potrebné zvoliť rozličné implementácie.

Implementácie dynamických množín

Pre jednoduchosť sa zaoberajme iba dynamickými množinami celých čísel. Bez ohľadu na konkrétnu implementáciu budeme takúto dynamickú množinu vždy uchovávať v štruktúre set. Navyše budeme mať implementovaných niekoľko funkcií, ktoré s dynamickými množinami pracujú. Kostra programu teda bude vyzerať pre ľubovoľnú implementáciu dynamickej množiny takto:

/* Struktura reprezentujuca dynamicku mnozinu. */
struct set {
    // ...
};

/* Funkcia, ktora vytvori prazdnu dynamicku mnozinu. */
void init(set &s) {
    // ...
}

/* Funkcia, ktora zisti, ci prvok x patri do mnoziny s. */
bool contains(set &s, int x) {
    // ...
}

/* Funkcia, ktora prida prvok x do mnoziny s. */
void add(set &s, int x) {
    // ...
}

/* Funkcia, ktora uvolni mnozinu s z pamate. */
void destroy(set &s) {
    // ...
}

Bez ohľadu na implementáciu štruktúry set a uvedených funkcií už teraz môžeme napísať program, ktorý ich využíva – bude postupne z konzoly čítať príkazy a postupne tieto príkazy vykonávať.

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

// ...

const int maxlength = 100;

int main(void) {
    set A;
    init(A);
    
    while (true) {
        char prikaz[maxlength];
        cin.width(maxlength);
        cin >> prikaz;
        if (strcmp(prikaz, "contains") == 0) {
            int x;
            cin >> x;
            cout << contains(A, x) << endl;        
        } else if (strcmp(prikaz, "add") == 0) {
            int x;
            cin >> x;
            add(A, x);
        } else if (strcmp(prikaz, "end") == 0) {    
            break;
        }
    }

    destroy(A);
    
    return 0;
}

Ukážeme si teraz niekoľko rôznych implementácii dynamickej množiny; začneme s dvoma, ktoré sú nám už v princípe známe.

Dynamická množina ako pole

Dynamickú množinu môžeme implementovať tak, že jej prvky budeme ukladať do poľa v ľubovoľnom poradí.

• Funkcia contains musí zakaždým prejsť celé pole lineárnym prehľadávaním (nie je teda zrovna rýchla).
• Funkcia add je naopak veľmi rýchla: stačí pridať prvok na koniec poľa.
• Je ale potrebné dávať pozor na prekročenie kapacity poľa (mohli by sme použiť dynamické pole).

#include <cassert>

// ...

const int maxN = 1000;

struct set {
    int *p;      // Smernik na nulty prvok pola.
    int length;  // Momentalna dlzka pola. 
};

void init(set &s) {
    s.p = new int[maxN];
    s.length = 0;
}

bool contains(set &s, int x) {
    for (int i = 0; i <= s.length - 1; i++) {
        if (s.p[i] == x) {
            return true;
        }
    }
    return false;
}

void add(set &s, int x) {
    assert(s.length < maxN);
    s.p[s.length] = x;
    s.length++;
}

void destroy(set &s) {
    delete[] s.p;
}

Dynamická množina ako utriedené pole

Prvky množiny môžeme v poli uchovávať aj utriedené od najmenšieho po najväčšie.

• Funkcia contains potom môže použiť binárne vyhľadávanie. Je teda rýchlejšia, ako v predchádzajúcom prípade (v poli veľkosti n sa pozrie len na približne log n pozícií; napríklad pre miliónprvkové pole sa pozrieme asi na 20 prvkov poľa).
• Funkcia add ale musí vložiť prvok na správne miesto v utriedenom poli; je teda o dosť pomalšia.

#include <cassert>

// ...

const int maxN = 1000;

struct set {
    int *p;      // Smernik na nulty prvok pola.
    int length;  // Momentalna dlzka pola. 
};

void init(set &s) {
    s.p = new int[maxN];
    s.length = 0;
}

bool contains(set &s, int x) {
    int left = 0;
    int right = s.length - 1;
    while (left <= right) {
        int index = (left + right) / 2;
        if (s.p[index] == x) {
            return true;
        } else if (s.p[index] > x) {
            right = index - 1;
        } else {
            left = index + 1;
        }    
    }
    return false;
}

void add(set &s, int x) {
    assert(s.length < maxN);
    int kam = s.length;
    while (kam > 0 && s.p[kam - 1] > x) {
        s.p[kam] = s.p[kam - 1];
        kam--;
    }
    s.p[kam] = x;
    s.length++;
}

void destroy(set &s) {
    delete[] s.p;
}

Ďalšie možnosti implementácie dynamickej množiny (plán na dnes)

Dnes uvidíme ďalšie dva spôsoby implementácie dynamickej množiny:

• Množina ako jednosmerne spájaný zoznam:
  • Ľahko pridáme nové prvky, nepotrebujeme vopred vedieť veľkosť.
  • Nedá sa rýchlo binárne vyhľadávať.
  • Založené na smerníkoch.
• Množina pomocou hešovania:
  • Často veľmi rýchle vyhľadávanie.
  • Použijeme polia aj spájané zoznamy.

Spájané zoznamy

Spájaný zoznam (angl. linked list) je postupnosť uzlov rovnakého typu usporiadaných za sebou. Každý uzol pritom pozostáva z dvoch častí:

• Samotné dáta; v našom prípade jedno číslo typu int.
• Smerník, ktorý ukazuje na nasledujúci prvok zoznamu – ten umožňuje „pohybovať sa” po zozname zľava doprava.

Posledný uzol zoznamu nemá následníka – jeho smerník na následníka teda bude mať hodnotu NULL.

Štruktúra spájaného zoznamu je znázornená na nasledujúcom obrázku:

Keďže si v každom uzle pamätáme iba smerník na následníka (t.j. uzol „napravo” od daného uzla), hovoríme tiež o jednosmerne spájanom zozname. Často sú užitočné aj obojsmerne spájané zoznamy, kde sa v každom uzle uchováva aj smerník na predchodcu; takéto zoznamy sú ale o niečo náročnejšie na „údržbu”.

Uzol jednosmerne spájaného zoznamu budeme reprezentovať pomocou struct-u node:

/* Struktura reprezentujuca uzol jednosmerne spajaneho zoznamu: */
struct node {
    int data;    // Hodnota ulozena v danom uzle
    node *next;  // Smernik na nasledujuci uzol
};

Vo vnútri definície typu node teda používame smerník na samotný typ node.

Na rozdiel od poľa, v ktorom je poradie stanovené indexmi, je poradie v spájanom zozname určované ukazovateľmi next. Ak x je uzol zoznamu, tak x.next je:

• Smerník na nasledujúci uzol zoznamu, ak takýto uzol existuje.
• NULL v opačnom prípade.

Samotný spájaný zoznam – resp. množina ním reprezentovaná – je potom iba štruktúra set obsahujúca smerník na prvý prvok zoznamu. Ak je zoznam prázdny, bude tento smerník NULL. V štruktúre set by sme v prípade potreby mohli uchovávať aj iné údaje, ako napríklad počet prvkov v zozname a podobne.

/* Struktura realizujuca mnozinu prostrednictvom spajaneho zoznamu: */
struct set {
    node *first; // Smernik na prvy uzol zoznamu
};

void init(set &s) {
    s.first = NULL;
}

Vkladanie na začiatok zoznamu

Nasledujúca funkcia na začiatok zoznamu vloží nový uzol s dátami x:

void add(set &s, int x) {
    node *p = new node;  // Vytvorime novy uzol ...
    p->data = x;         // ... a jeho data nastavime na x.
    p->next = s.first;   // Naslednikom noveho uzla p v zozname bude doposial prvy prvok zoznamu ...
    s.first = p;         // ... a uzol p bude odteraz novym prvym prvkom v zozname.
}

Vyhľadávanie v zozname

Funkcia vyhľadávajúca číslo x v zozname bude pracovať tak, že postupne prehľadáva zoznam od jeho začiatku, s využitím smerníkov na nasledujúce prvky:

bool contains(set &s, int x) {
    node *p = s.first;
    while (p != NULL) {
        if (p->data == x) {
            return true;
        } 
        p = p->next;
    }
    return false;
}

Uvoľnenie zoznamu

Funkcia realizujúca uvoľnenie zoznamu z pamäti pracuje podobne – prechádza postupne zoznam od začiatku až po jeho koniec a uvoľňuje z pamäte jednotlivé uzly. Treba si tu však dať pozor na to, aby sme smerník na nasledujúci uzol získali ešte predtým, než z pamäti uvoľníme ten predošlý.

void destroy(set &s) {
    node *p = s.first;
    while (p != NULL) {
        node *nxt = p->next;
        delete p;
        p = nxt;
    }
}

Výpis zoznamu

Môžeme napísať aj nasledujúcu funkciu, ktorá po zavolaní vypíše obsah celého zoznamu:

void print(set &s) {
    node *p = s.first;
    while (p != NULL) {
        cout << p->data << " ";
        p = p->next;
    }   
    cout << endl; 
}

Hešovanie

Implementácia množiny priamym adresovaním

Úplne odlišným spôsobom realizácie dynamickej množiny je tzv. priame adresovanie (angl. direct addressing). Predpokladajme, že je univerzum všetkých hodnôt konečné – napríklad U = {0,1,...,m-1} pre nejaké prirodzené číslo m. V takom prípade môžeme množinu A prvkov U reprezentovať ako pole boolovských hodnôt dĺžky m zodpovedajúce charakteristickej funkcii množiny A.

• Funkcie contains aj add sú veľmi rýchle.
• Problémom tohto prístupu je ale vysoká pamäťová zložitosť v prípade, že je číslo m veľké.

#include <cassert>

// ...

const int maxvalue = 1000;

/* Struktura realizujuca mnozinu prostrednictvom priameho adresovania: */
struct set {
    bool *p;
};

void init(set &s) {
    s.p = new bool[maxvalue];
    for (int i = 0; i <= maxvalue - 1; i++) {
        s.p[i] = false;
    }
}

bool contains(set &s, int x) {
    assert(x >= 0 && x <= maxvalue - 1);
    return s.p[x];  
}

void add(set &s, int x) {
    assert(x >= 0 && x <= maxvalue - 1);
    s.p[x] = true;
}

void destroy(set &s) {
    delete[] s.p;
}

Jednoduché hešovanie

Priame adresovanie sa príliš nehodí, ak prvky môžu byť veľmi veľké – v takom prípade je totiž potrebné veľké množstvo pamäte.

Hešovanie je jednoduchá finta, ktorá funguje nasledovne:

• Nech U je univerzum všetkých možných prvkov množiny (kľúčov).
• Vytvoríme tzv. hešovaciu tabuľku hashtable – pole nejakej rozumnej veľkosti m, pozostávajúce z prvkov rovnakého typu ako prvky univerza, napríklad int.
• Naprogramujeme hešovaciu funkciu, ktorá transformuje prvky univerza U na indexy hešovacej tabuľky; pôjde teda o funkciu h: U -> {0, 1, ... , m−1}.
• Hešovacia funkcia by mala byť jednoduchá a rýchla, ale pritom by nemala „často prideľovať rovnaké indexy” (mala by kľúče do tabuľky distribuovať rovnomerne).
• Najjednoduchšia hešovacia funkcia je h(x) = x mod m (je dobré, ak je v tomto prípade m prvočíslo a nie je blízko mocniny 2).
  • Pozor: napríklad -10 % 3 je -1, takže radšej použijeme absolútnu hodnotu z x (funkcia abs z knižnice cstdlib).

int hash(int x, int m) {
    return abs(x) % m;
}

S hešovacou tabuľkou teraz môžeme pracovať nasledovne:

Vkladanie prvku x:

• Spočítame index = hash(x, m) a prvok vložíme na pozíciu hashtable[index].

Vyhľadávanie prvku x:

• Ak je prvok s kľúčom x v tabuľke, musí byť na indexe hash(x, m).
• Skontrolujeme túto pozíciu a ak tam je niečo iné ako x, prvok x sa v tabuľke nenachádza.

Problémy:

• Na akú hodnotu inicializovať prvky poľa hashtable?
• Čo ak budeme potrebovať vložiť prvok na miesto, kde je už 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 a existuje viacero spôsobov, ako sa s ním vysporiadať. Naše riešenie bude spočívať v nasledujúcej myšlienke:

• Budeme aj tak vkladať na dané miesto, na ktorom už teda bude môcť byť viac ako jeden prvok.
• Prvky na danej pozícii hešovacej tabuľky budeme uchovávať v spájanom zozname.

Existujú však aj iné prístupy – môžeme napríklad hľadať iné voľné miesto v tabuľke a podobne (viac budúci rok na predmete Algoritmy a dátové štruktúry).

Riešenie kolízií pomocou spájaných zoznamov

V každom políčku hešovacej tabuľky teda budeme uchovávať spájaný zoznam so všetkými prvkami množiny, ktoré hešovacia funkcia priradila na toto políčko.

#include <cstdlib>

// ...

/* Hesovacia funkcia: */
int hash(int x, int m) {
    return abs(x) % m;
}

/* Struktura reprezentujuca jeden prvok spajaneho zoznamu: */
struct node {
    int data;
    node *next;
};

/* Struktura realizujuca dynamicku mnozinu pomocou hesovania: */
struct set {
    node **hashtable;  // Pole smernikov na zaciatky jednotlivych zoznamov
    int m;             // Velkost hesovacej tabulky  
};

void init(set &s, int m) {  // Velkost tabulky bude parametrom funkcie init
    s.m = m;
    s.hashtable = new node *[m];
    for (int i = 0; i <= m - 1; i++) {
        s.hashtable[i] = NULL;
    }
}

bool contains(set &s, int x) {
    int index = hash(x, s.m);     // Spocitame spravne policko hesovacej tabulky
    node *p = s.hashtable[index]; // Smernik p ukazuje na prvy prvok spajaneho 
                                  // zoznamu na danom policku
    while (p != NULL) {           // Prechadzame zoznam, hladame x
        if (p->data == x) {
            return true;
        }
        p = p->next;
    } 
    return false;    
}

void add(set &s, int x) {
    int index = hash(x, s.m);        // Spocitame spravne policko hesovacej tabulky
    node *temp = new node;           // Vytvorime novy uzol do spajaneho zoznamu 
    temp->data = x;               
    temp->next = s.hashtable[index]; // Vlozime uzol temp na zaciatok zoznamu.
    s.hashtable[index] = temp;       
}

void destroy(set &s) {
    for (int i = 0; i <= s.m - 1; i++) {
        node *p = s.hashtable[i];   // Uvolni zoznam s.hashtable[i]
        while (p != NULL) {
            node *nxt = p->next;
            delete p;
            p = nxt;
        }
    }
    delete[] s.hashtable;
}

Cvičenie: Ako bude vyzerať hešovacia tabuľka pri riešení kolízií pomocou spájaných zoznamov, ak hešovacia funkcia je |x| 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, a teda musíme pri hľadaní prejsť všetky prvky množiny.
• Ak máme šťastie a v každom políčku máme len málo prvkov, bude aj vyhľadávanie rýchle.
  • Ak je tabuľka dosť veľká a hešovacia funkcia vhodne zvolená, tento prípad je pomerne obvyklý.
  • Hešovacie tabuľky sa často používajú v praxi.
• Viac budúci rok na predmete Algoritmy a dátové štruktúry.

Prednáška 15

Oznamy

• V piatok budú vo zvyčajnom čase doplnkové cvičenia, na ktorých bude možné riešiť bonusovú rozcvičku.
• Druhá písomka bude v stredu 20. novembra o 18:10 v miestnosti A.

Práca s konzolou na spôsob jazyka C: printf a scanf

Doposiaľ sme s konzolou pracovali prostredníctvom knižnice iostream, ktorá patrí medzi štandardné knižnice jazyka C++ a v ktorej sú definované štandardné vstupno-výstupné prúdy cin a cout. V nasledujúcom si ukážeme alternatívny prístup k práci s konzolou založený na knižnici cstdio, ktorá je štandardnou knižnicou jazyka C. Rovnako ako nižšie sa tak so vstupom a výstupom dá pracovať aj v jazyku C.

Výpis formátovaných dát na konzolu: printf

S použitím knižnice cstdio možno na konzolu písať pomocou funkcie printf. Jej základné použitie môže vyzerať napríklad takto:

#include <cstdio>

int main(void) {
    printf("Ahoj svet, este raz!\n");
    return 0;
}

Funkciu printf možno volať aj s viac ako jedným argumentom. Vo všeobecnosti vyzerá jej volanie nasledovne:

printf(format, hodnota1, hodnota2, ...)

Prvým argumentom je takzvaný formátovací reťazec, za ním nasleduje niekoľko ďalších argumentov (prípadne aj žiaden). Formátovací reťazec pozostáva z dvoch druhov znakov: bežné znaky, ktoré sa priamo vypíšu na výstup a takzvané špecifikácie konverzií začínajúce symbolom % a končiace tzv. znakom konverzie, ktoré majú za následok vypísanie niektorého z ďalších argumentov funkcie printf (presnejšie prvého ešte nevypísaného argumentu). V rámci špecifikácie konverzie možno zadať formát, v ktorom sa má ten-ktorý argument vypísať.

Napríklad

#include <cstdio>

int main(void) {
    int n = 7;
    printf("Prve cislo je %d a druhe cislo je %d.\n",1+1,n);
    return 0;
}

vypíše

Prve cislo je 2 a druhe cislo je 7.

Špecifikácia %d tu pozostáva iba zo znaku konverzie d, ktorý zodpovedá výpisu celého čísla v desiatkovej sústave.

Ďalšie príklady znakov konverzie:

• %f: reálne číslo.
• %e: reálne čislo vo vedeckej notácii, napr. 5.4e7.
• %x: celé číslo v šestnástkovej sústave.
• %c: znak (char).
• %s: reťazec (char *).
• %%: vypíše samotný znak %.

Pozor: typy jednotlivých argumentov musia byť v súlade s formátovacím reťazcom (pričom vo všeobecnosti nedôjde k automatickému pretypovaniu).

Pred samotný znak konverzie možno pridávať aj modifikátory l, ll, resp. h zodpovedajúce modifikátorom typov long, long long, resp. short. Napríklad

• %lld: vypíše „veľmi dlhé” celé číslo.
• %lf: vypíše reálne číslo typu double; pri vypisovaní možno to isté urobiť aj pomocou %f, ale neskôr pri načítavaní bude nutné pre typ double naozaj používať %lf.

Formátovanie výstupu

Formát vypísania daného argumentu možno zadať niekoľkými nepovinnými parametrami medzi symbolom % a znakom konverzie. Napríklad:

• %.2f: vypíše reálne číslo na 2 desatinné miesta.
• %4d: ak má celé číslo menej ako 4 cifry, doplní vľavo medzery.
• %04d: podobne, ale dopĺňa nuly.

Nasledujúci program vo vhodnom formáte vypíše hodnoty faktoriálu prirodzených čísel od 1 po 20:

#include <cstdio>

long long int factorial(int n) {                      
    if (n == 0) {
        return 1;
    } else {
        return n * factorial(n-1);
    }
}

int main(void) {
    for (int i = 1; i <= 20; i++) {                   
        printf("%2d! = %22lld\n",i,factorial(i));
    }
    return 0;
}

Nasledujúci program vypíše vo vhodnom formáte zadaný dátum:

#include <cstdio>

void vypisDatum(int d, int m, int r) {
    printf("%02d.%02d.%04d\n",d,m,r);
}

int main(void) {
    vypisDatum(2,1,2019);
    return 0;
}

Celá špecifikácia konverzie pozostáva z nasledujúcich častí:

• Z povinného úvodného znaku %.
• Z jedného alebo niekoľkých nepovinných príznakov, ako napríklad -, ktorého použitie vyústi v zarovnanie vypisovaného textu vľavo (bez jeho použitia sa text zarovná vpravo). Ďalšími príznakmi sú napríklad 0 (dopĺňanie núl naľavo), + (vypíše znamienko + pri kladných číslach), atď.
• Z nepovinného celého čísla udávajúceho minimálnu šírku výpisu (minimálny počet „políčok”, do ktorých sa text vypíše).
• Z nepovinnej bodky nasledovanej celým číslom udávajúcim presnosť výpisu (pri reálnych číslach napríklad počet desatinných miest; presnosť má však svoju interpretáciu aj pri iných typoch dát).
• Z nepovinného modifikátora l, ll, alebo h pre long, long long, resp. short.
• Z povinného symbolu konverzie (napr. d, f, s, ...).

Načítanie formátovaných dát z konzoly: scanf

Funkciu scanf s typickým volaním

scanf(format, adresa1, adresa2, ...)

možno využiť na načítanie dát z konzoly.

• Napríklad scanf("%d", &x) načíta celočíselnú hodnotu do premennej x.
• Zatiaľ čo argumentmi printf sú priamo hodnoty, scanf potrebuje adresy premenných, pretože ich modifikuje.

Jednoduchý príklad použitia:

#include <cstdio>

void vypisDatum(int d, int m, int r) {
    printf("%02d.%02d.%04d\n",d,m,r);
}

int main(void) {
    int r;

    printf("Zadaj rok: ");  
    scanf("%d", &r);        
    vypisDatum(1,1,r);                   
    return 0;
}

Pomocou scanf možno načítať aj viacero premenných naraz:

#include <cstdio>

void vypisDatum(int d, int m, int r) {
    printf("%02d.%02d.%04d\n",d,m,r);
}

int main(void) {
    int d,m,r;

    printf("Zadaj den, mesiac a rok: ");  
    scanf("%d %d %d", &d, &m, &r);        
    vypisDatum(d,m,r);                    
    return 0;
}

Formátovací reťazec sa teraz interpretuje nasledovne:

• Špecifikácie formátov načítavaných premenných (začínajúce znakom %) možno zadávať podobne ako pri funkcii printf.
  • Pre načítanie reálneho čísla typu double je potrebné použiť %lf, kým pri funkcii printf stačí aj %f.
• Biele znaky (angl. whitespace; t.j. medzery, konce riadkov, tabulátory) vo formátovacom reťazci spôsobia, že funkcia scanf číta a ignoruje všetky biele znaky pred ďalším nebielym znakom. Jeden biely znak vo formátovacom reťazci tak umožní ľubovoľný počet bielych znakov na vstupe.
• Ostatné znaky formátovacieho reťazca musia presne zodpovedať vstupu.

Nasledujúci príkaz tak napríklad načíta dátum vo formáte deň.mesiac.rok:

scanf("%d.%d.%d", &d, &m, &r);

Kontrola správnosti vstupu

Funkcia scanf vracia na výstupe počet úspešne načítaných hodnôt zo vstupu. V prípade chyby hneď na začiatku vstupu tak napríklad vráti 0. V prípade, že hneď na začiatku narazí na koniec súboru (ktorý na konzole možno zadať pod Linuxom ako Ctrl+D resp. pod Windowsom ako Ctrl+Z a Enter), vráti hodnotu EOF (typicky -1).

Príklad: zadávanie dátumu vo formáte deň.mesiac.rok s kontrolou vstupu:

#include <cstdio>

void vypisDatum(int d, int m, int r) {
    printf("%02d.%02d.%04d\n",d,m,r);
}

int main(void) {
    int d,m,r;
    printf("Zadaj datum: ");  
    if (scanf("%d.%d.%d", &d, &m, &r) == 3) {
        printf("Datum je ");
        vypisDatum(d,m,r);
    } else {
        printf("Nebol zadany korektny datum.\n");
    }
    return 0;
}

Ďalším príkladom môže byť program, ktorý počíta súčet postupne zadávaných čísel, až kým je zadané nekorektné číslo alebo koniec súboru:

#include <cstdio>

int main(void) {
    double sum = 0;
    double x;
    while (scanf("%lf", &x) == 1) {
         sum += x;
    }
    printf("Sucet je %.2f\n", sum);
    return 0;
}

Textové súbory

Na načítavanie a vypisovanie dát sme doposiaľ používali výhradne konzolu. V praxi však často vzniká potreba spracovávať dáta uložené v súboroch. Zameriame sa teraz na súbory v textovom formáte, s ktorými sa pracuje podobne ako s konzolou.

Základy: typ FILE * a funkcie fopen, fclose, fprintf, fscanf

So súbormi sa pri použití knižnice cstdio pracuje pomocou typu FILE *. Ide tu o smerník na štruktúru typu FILE, ktorá obsahuje nejaké (pre programátora zväčša nepodstatné) informácie o súbore, s ktorým sa práve pracuje. Premenné pre prácu so súbormi tak možno definovať napríklad takto:

FILE *f;
FILE *fr, *fw;

Pozor: v názve typu FILE treba dodržať veľké písmená (čiže treba písať FILE *, nie file *).

Otvorenie súboru pre čítanie

• fr = fopen("vstup.txt", "r");
• Otvorí súbor s názvom vstup.txt (prípadne možno zadať kompletnú cestu k súboru).
• Ak taký súbor neexistuje alebo sa nedá otvoriť, do fr priradí NULL.
• Z takto otvoreného súboru môžeme čítať napríklad pomocou fscanf, ktorá je analógiou k scanf.
• Napríklad 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 (keby sme vo volaní fopen namiesto "w" použili "a", pridávalo by sa na koniec existujúceho súboru).
• Ak sa nepodarí súbor otvoriť, do fw priradí NULL.
• Do takto otvoreného súboru môžeme zapisovať napr. pomocou funkcie fprintf, ktorá je analógiou k printf.
• Napr. fprintf(fw, "%d", x);

Zatvorenie súboru

• Po ukončení práce so súborom je ho potrebné zavrieť pomocou fclose(f);
• Počet súčasne otvorených súborov je obmedzený.

Príklad

Nasledujúci program načíta číslo n a následne n celých čísel zo súboru vstup.txt. Do súboru vystup.txt vypíše vstupné čísla v opačnom poradí.

#include <cstdio>
#include <cassert>

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");  
    FILE *fw = fopen("vystup.txt", "w");
    assert(fr != NULL && fw != NULL);
    
    int n,r;
    r = fscanf(fr, "%d", &n);
    assert(r == 1 && n >= 0);
    int *a = new int[n];
    
    for (int i = 0; i <= n-1; i++) {
        r = fscanf(fr, "%d", &a[i]);
        assert(r == 1);
    }
    fclose(fr);
    for (int i = n-1; i >= 0; i--) {
        fprintf(fw, "%d ", a[i]);
    }
    fclose(fw);
    delete[] a;    
    return 0;
}

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

So štandardným vstupom a výstupom sa pracuje rovnako ako so súborom. V cstdio sú definované dva konštantné smerníky

FILE *stdin, *stdout;

pre štandardný vstupný a výstupný prúd. Tie tak môžu byť použité v ľubovoľnom kontexte, v ktorom sa očakáva súbor. Napríklad volanie fscanf(stdin,"%d",&x) je ekvivalentné volaniu scanf("%d",&x).

Ten istý kód sa tak dá použiť na prácu so súbormi aj so štandardným vstupom resp. výstupom – stačí len podľa potreby nastaviť premennú typu FILE *. Typické použitie je napríklad nasledovné:

    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

Existujú dve možnosti testovania „nárazu” na koniec súboru:

• V knižnici cstdio je definovaná symbolická konštanta EOF, ktorá má väčšinou hodnotu -1. Ak sa funkcii fscanf nepodarí načítať žiadnu hodnotu, pretože načítavanie dospelo ku koncu súboru, vráti konštantu EOF ako svoj výstup.
• Funkcia feof(subor) vráti true práve vtedy, keď sa funkcia fscanf (alebo nejaká iná funkcia) už niekedy pokúšala čítať za koncom súboru subor.

Spracovanie vstupu pozostávajúceho z postupnosti čísel

Často na vstupe očakávame postupnosť číselných hodnôt oddelených bielymi znakmi. Pozrime sa na tri obvyklé možnosti, ako môže byť takýto vstup zadaný a spracovaný pomocou funkcie fscanf.

Formát 1: N (počet čísel) a následne N ďalších čí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á číslom -1 alebo inou špeciálnou hodnotu.

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

Priamočiary prístup 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 v súbore často nasleduje ešte koniec riadku, v dôsledku čoho môže posledné volanie funkcie fscanf vyústiť v návratovú hodnotu -1 (predchádzajúce volanie fscanf totiž ešte „nenarazilo” na koniec súboru, v dôsledku čoho je pred čítaním posledného riadku hodnota feof(f) stále rovná false). Tým pádom program zlyhá na riadku assert(kod == 1). Tento nedostatok môžeme napraviť napríklad tak, že vo volaní funkcie fscanf dáme vo formátovacom reťazci za %d medzeru. Tá sa bude pokúšať preskočiť všetky biele znaky až po najbližší nebiely; pritom natrafí na koniec súboru a feof(f) už bude vracať true.

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

Prednáška 16

Oznamy

• Druhá písomka bude v stredu 20. novembra o 18:10 v miestnosti A.
• Tretiu domácu úlohu je potrebné odovzdať do pondelka 25. novembra, 22:00.

Príklad na prácu s textovými súbormi

Na minulej prednáške sme sa zaoberali základnými technikami práce s textovými súbormi s využitím knižnice cstdio. V rámci ich opakovania uvažujme nasledujúci problém: máme daných niekoľko „čiastkových” textových súborov, z ktorých každý obsahuje postupnosť niekoľkých celých čísel. Hlavný vstupný súbor vstup.txt potom pozostáva z:

• Prvého riadku obsahujúceho názov výstupného súboru.
• Niekoľkých ďalších riadkov zakaždým obsahujúcich názov niektorého „čiastkového” súboru nasledovaný celým číslom.

Úlohou je pre každú dvojicu tvorenú názvom „čiastkového” súboru a číslom N, uvedenú v súbore vstup.txt, prekopírovať z daného „čiastkového” súboru do výstupného súboru prvých N čísel.

Napríklad pre „čiastkový” súbor a.txt pozostávajúci z čísel

1 2 3 4 5 6 7 8 9

a „čiastkový” súbor b.txt pozostávajúci z čísel

10 20 30 40 50 60 70 80 90

sa pre hlavný vstupný súbor vstup.txt daný ako

vystup.txt
a.txt 2
b.txt 1
a.txt 3

majú do výstupného súboru vystup.txt nakopírovať hodnoty

1 2 10 1 2 3

Túto úlohu realizuje program uvedený nižšie, ktorý pracuje v nasledujúcich krokoch:

• Otvorí hlavný vstupný súbor vstup.txt a prečíta z neho názov výstupného súboru.
• Otvorí výstupný súbor.
• Následne, až kým nenarazí na koniec hlavného vstupného súboru, opakuje nasledujúce:
  • Z hlavného vstupného súboru prečíta názov „čiastkového” súboru a prirodzené číslo N.
  • Otvorí „čiastkový” súbor s práve načítaným názvom, prekopíruje z neho N čísel do výstupného súboru a následne tento „čiastkový” súbor zatvorí.
• Zatvorí hlavný vstupný súbor aj výstupný súbor.

Dĺžka načítavaných reťazcov bude vo volaniach funkcie fscanf obmedzená na 19 znakov (to teda bude maximálna dĺžka názvu súboru, s ktorou bude program vedieť pracovať).

#include <cstdio>
#include <cassert>

int main(void) {
    FILE *fr_main, *fr_part, *fw;
    int N,r,num;
    fr_main = fopen("vstup.txt", "r");
    assert(fr_main != NULL);
    
    char filename[20];
    r = fscanf(fr_main,"%19s",filename);
    assert(r == 1); 
    
    fw = fopen(filename, "w");
    assert(fw != NULL);
    while (!feof(fr_main)) {
        r = fscanf(fr_main,"%19s %d ",filename,&N);
        assert(r == 2);
        fr_part = fopen(filename, "r");
        assert(fr_part != NULL);
        for (int i = 0; i <= N-1; i++) {
            r = fscanf(fr_part, "%d ", &num);
            assert(r == 1);
            fprintf(fw, "%d ", num);
        }
        fclose(fr_part);
    }
    fclose(fw);
    fclose(fr_main); 
    return 0;
}

Čítanie a zapisovanie po znakoch

Knižnica cstdio obsahuje funkciu

int getc(FILE *f);

ktorá načíta jeden znak zo súboru, na ktorý odkazuje smerník f. V prípade, že načítanie prebehne úspešne, je výstupom funkcie getc kód tohto znaku. V opačnom prípade je výstupom špeciálna konštanta EOF, ktorá je vždy rôzna od ľubovoľnej hodnoty typu char; to je aj dôvod, prečo funkcia getc nevracia hodnotu typu char, ale hodnotu typu int. Je preto dôležité vyvarovať sa ukladania výstupnej hodnoty funkcie getc do premennej typu char – v takom prípade nie je možné rozoznať koniec súboru. Funkcia

int getchar(void);

je skratkou pre getc s parametrom stdin; načíta tak jeden znak z konzoly (rovnako ako napríklad pri scanf sa však vstup začne spracovávať až potom, ako používateľ stlačí Enter – nie je takto možné reagovať priamo na stlačenie nejakej klávesy).

Výstupným náprotivkom k funkcii getc je funkcia

int putc(int c, FILE *f);

Tá zapíše znak c do súboru, na ktorý odkazuje smerník f. Funkcia

int putchar(int c);

je skratkou pre putc s parametrami c a stdout; vypíše teda daný znak na konzolu.

Príklad: kopírovanie súboru

Nasledujúci program skopíruje obsah súboru original.txt do súboru kopia.txt.

#include <cstdio>

int main(void) {
    FILE *fr = fopen("original.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);

    return 0;
}

Načítavanie pritom možno realizovať aj priamo v podmienke cyklu while – výstupom priradenia c = getc(fr) je nová hodnota premennej c, ktorú možno hneď porovnať s EOF. Kľúčová časť horeuvedeného programu sa tak dá kratšie, hoci menej čitateľne, prepísať takto:

    int c;
    while ((c = getc(fr)) != EOF) {
        putc(c, fw);
    }

Konce riadkov

Koniec riadku je reprezentovaný znakom '\n'. Pri čítaní alebo zápise sa môže prekladať na jeden alebo dva znaky v závislosti od operačného systému (<LF>, <CR><LF>, alebo <CR>).

Cvičenie: č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);
   
    return 0; 
}

Funkcia ungetc

Signálom na ukončenie načítavania znakov často býva až „náraz” na znak, ktorý už nie je žiadúce prečítať. V takom prípade je užitočné „posunúť sa v načítavaní o jeden krok nazad”. Túto úlohu realizuje funkcia

int ungetc(int c, FILE * f);

Ak bol posledným načítaným znakom (zo súboru, na ktorý odkazuje smerník f) znak c, volanie ungetc(c,f) má skutočne efekt „kroku nazad”. Ako parameter funkcie ungetc však možno okrem naposledy prečítaného znaku použiť aj ľubovoľný iný znak c – funkcia ungetc potom tento znak „virtuálne” pridá na začiatok neprečítanej časti súboru. Súbor sa teda reálne nemení, ale pri nasledujúcom čítaní z neho sa ako prvý prečíta znak c. V prípade úspechu sa po volaní ungetc(c,f) vráti hodnota c; v prípade neúspechu je výstupom konštanta EOF.

Takéto správanie funkcie ungetc je však garantované len v prípade, že sa táto funkcia nevolá viackrát za sebou.

Príklad č. 1: Nasledujúci kus programu skonvertuje reťazec pozostávajúci zo znakov '0' až '9' 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);

Príklad č. 2: Nasledujúci program prečíta číslo pomocou funkcie 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);

    return 0;
}

Čítanie a zapisovanie po riadkoch

V knižnici cstdio je definovaná funkcia

char *fgets(char *str, int n, FILE * f);

pomocou ktorej možno načítať zo súboru, na ktorý ukazuje smerník f, práve jeden riadok (alebo nejakú jeho časť, ak je tento riadok príliš dlhý). Vstupnými argumentmi funkcie fgets sú:

• Pole znakov str, do ktorého sa v prípade úspechu riadok načíta.
• Číslo n určujúce maximálny počet znakov skopírovaných do poľa str. Presnejšie: do poľa str sa z daného riadku súboru skopíruje najviac n-1 znakov a reťazec str sa následne ukončí znakom \0. Pri typickom volaní funkcie fgets je teda n rovné dĺžke poľa str.
• Smerník f na súbor, z ktorého sa má riadok prečítať.

Funkcia fgets na týchto argumentoch postupne načítava znaky zo súboru, na ktorý ukazuje smerník f, pričom ich ukladá do str. To robí až dovtedy, kým narazí na koniec riadku (\n) alebo koniec súboru, prípadne kým sa zo súboru neprečíta n-1 znakov. Prípadný znak \n na konci riadku sa (pokiaľ nebolo načítaných príliš veľa znakov) nezahodí, ale pridá sa na koniec reťazca str. Výstupom funkcie fgets je v prípade načítania aspoň jedného znaku načítaný reťazec str; v prípade „nárazu” na koniec súboru je výstupom NULL a reťazec str ostáva nezmenený.

Príklad: nasledujúci program spočíta počet riadkov v súbore vstup.txt (za predpokladu, že žiaden z týchto riadkov nie je dlhší ako 100 znakov vrátane znaku \n na konci riadku):

#include <cstdio>

const int maxN = 101;

int main(void) {
    char str[maxN];
    int num = 0;
    
    FILE *fr = fopen("vstup.txt", "r");
    while (fgets(str, maxN, fr) != NULL) {
        num++;
    }
    fclose(fr);
    
    printf("%d\n",num);
    
    return 0;
}

Cvičenie: Zistite, ako sa správa uvedený program, keď posledným znakom v súbore je resp. nie je znak \n. Zistite, čo program vypíše na výstup pre súbor, ktorý obsahuje jediný riadok o 200 znakoch.

Výstupným náprotivkom funkcie fgets je funkcia

int fputs(const char *str, FILE *f);

ktorá do súboru, na ktorý ukazuje smerník f, vypíše reťazec str. Vypisovaný reťazec str pritom môže obsahovať ľubovoľný (aj nulový) počet výskytov symbolu \n pre koniec riadku. V prípade úspechu vráti funkcia fputs nezáporné celé číslo; v prípade neúspechu vráti konštantu EOF.

Prístupy k spracovaniu textového vstupu

Vstup môže byť v textovom súbore zadaný v rôznych formátoch. V závislosti od formátu potom môžu byť výhodnými rôzne spôsoby jeho spracovania. Často používanými prístupmi k spracovaniu textového vstupu sú napríklad nasledujúce:

• Pomocou funkcie fscanf postupne načítať jednotlivé čísla, slová, a podobne. Tento prístup býva zvyčajne výhodný vtedy, keď sa všetky biele znaky považujú za ekvivalentné oddeľovače.
• Pomocou funkcie getc spracovať vstupný súbor po znakoch. Tu ide o relatívne univerzálny spôsob spracovania vstupu, ktorý je však v niektorých situáciách pomerne prácny.
• Pomocou funkcie fgets postupne prečítať jednotlivé riadky do reťazca a tento reťazec následne spracovať. Tento prístup je výhodný najmä vtedy, keď má koniec riadku funkciu prirodzeného oddeľovača vstupov a keď je dĺžka riadku predom obmedzená.

Často môže byť užitočné horeuvedené prístupy aj navzájom kombinovať.

Príklad č. 1: predpokladajme, že potrebujeme nájsť dĺžku najdlhšieho riadku v súbore (vrátane symbolu \n, ktorý sa môže vyskytovať na jeho konci). Nasledujúce dva programy túto úlohu riešia dvoma odlišnými spôsobmi:

• Prvý program postupne načítava riadky do reťazca, ktorý následne spracúva (problém, ak je riadok príliš dlhý).
• Druhý program číta súbor po znakoch, pričom si udržiava premennú pocet uchovávajúcu informáciu o tom, koľko písmen sa už v momentálne spracovávanom riadku načítalo.

#include <cstdio>
#include <cstring>

const int maxN = 100;

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int maxDlzka = 0;
    char str[maxN];
    while (fgets(str, maxN, fr) != NULL) {
        int dlzka = strlen(str);
        if (dlzka > maxDlzka) {
            maxDlzka = dlzka;
        }
    }
    fclose(fr);
    printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka);
    return 0;
}

#include <cstdio>

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int maxDlzka = 0;
    int dlzka = 0;
    int c = getc(fr);
    while (c != EOF) {
        dlzka++;
        if (c == '\n') {
            if (dlzka > maxDlzka) {
                maxDlzka = dlzka;
            }
            dlzka = 0;
        }
        c = getc(fr);
    }
    if (dlzka > maxDlzka) { // Posledny riadok nemusi koncit symbolom \n.
        maxDlzka = dlzka;
    }
    fclose(fr);
    printf("Najdlhsi riadok ma dlzku %d\n", maxDlzka);
    return 0;
}

Príklad č. 2: nasledujúci program spracúva vstupný súbor obsahujúci čísla oddelené bielymi znakmi (medzery, tabulátory, konce riadkov,...), pričom medzi dvoma číslami môže byť aj viac ako jeden oddeľovač. Pre každý riadok program vypíše súčet čísel, ktoré sa v tomto riadku vyskytujú (predpokladá pritom, že každý – t. j. aj posledný – riadok vstupného súboru je ukončený symbolom \n).

Vzhľadom na to, že tu ide o pomerne nepríjemnú kombináciu rozlišovania koncov riadku od iných bielych znakov a čítania formátovaných hodnôt (čísel), kombinuje nasledujúci program čítanie po znakoch s využívaním funkcie fscanf. Pracuje pritom nasledovne:

• Kým sú na vstupe biele znaky, spracúva ich pomocou funkcie getc. Ak je niektorý z týchto znakov koncom riadku, vypíše zistený súčet čísel.
• Po „náraze” na prvý nebiely znak použije funkciu ungetc na jeho vrátenie do vstupného prúdu. Následne prečíta číslo pomocou funkcie fscanf a na základe prečítanej hodnoty aktualizuje súčet.
• Na zistenie, či je prečítaný znak biely, využíva nasledujúci program funkciu isspace z knižnice cctype.

#include <cstdio>
#include <cctype>

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    int sucet = 0;
    int hodnota;
    while (!feof(fr)) {
        int c = getc(fr);
        while (c != EOF && isspace(c)) { // Precitaj biele znaky po najblizsi nebiely.
            if (c == '\n') {             // Na konci riadku vypis sucet.
                printf("Sucet %d\n", sucet);
                sucet = 0;
            }
            c = getc(fr);
        }
        if (c == EOF) {                  // Pri naraze na koniec suboru nepokracuj dalej.
            break;
        }                
        ungetc(c, fr);                   // Posledny precitany znak nebol biely; vrat ho do vstupneho prudu.
        fscanf(fr, "%d", &hodnota);      // Precitaj cislo a pripocitaj ho k suctu.
        sucet += hodnota;
    }
    fclose(fr);
    return 0;
}

Cvičenie: upravte program tak, aby pracoval správne aj v prípade, že posledný riadok nie je ukončený symbolom \n.

Jednoduché šifrovanie

Prácu so súbormi si v nasledujúcom precvičíme na dvoch jednoduchých šifrách.

Cézarova šifra

Cézarova šifra je šifra, pri ktorej sa každé písmeno vstupného reťazca posunie cyklicky o K miest v abecednom poradí, kde K je zadaný parameter šifry (tzv. posun).

• Napríklad pre K=2 sa písmeno A zmení na C, písmeno b sa zmení na d a písmeno Z sa zmení na B.
• Ukážeme si jej použitie pre anglickú abecedu (t. j. znaky 'a' až 'z' a 'A' až 'Z' bez diakritiky); je ju ale možné upraviť napríklad aj tak, aby pracovala s ASCII kódmi.

Zašifrovanie súboru realizuje nasledujúci program:

#include <cstdio>
#include <cassert>

void encryptCaesar(FILE *fr, FILE *fw, int shift) {
    assert(shift >= 0 && shift <= 25);
    int c;
    while ((c = getc(fr)) != EOF) {
        if ((c >= 'A') && (c <= 'Z')) {
            c = c + shift;
            if (c > 'Z') {
                c -= 26;
            }
        } else if ((c >= 'a') && (c <= 'z')) {
            c = c + shift;
            if (c > 'z') {
                c -= 26;
            }
        }
        putc(c, fw);
    }
}

int main(void) {
    int shift;
    scanf("%d", &shift);
    
    FILE *fr = fopen("plaintext.txt", "r");
    FILE *fw = fopen("ciphertext.txt", "w");
    
    encryptCaesar(fr, fw, shift);
    
    fclose(fr);
    fclose(fw);
    
    return 0;
}

Dešifrovanie súboru zašifrovaného Cézarovou šifrou realizuje tento program:

#include <cstdio>
#include <cassert>

void decryptCaesar(FILE *fr, FILE *fw, int shift) {
    assert(shift >= 0 && shift <= 25);
    int c;
    while ((c = getc(fr)) != EOF) {
        if ((c >= 'A') && (c <= 'Z')) {
            c = c - shift;
            if (c < 'A') {
                c += 26;
            }
        } else if ((c >= 'a') && (c <= 'z')) {
            c = c - shift;
            if (c < 'a') {
                c += 26;
            }
        }
        putc(c, fw);
    }
}

int main(void) {
    int shift;
    scanf("%d", &shift);
    
    FILE *fr = fopen("ciphertext.txt", "r");
    FILE *fw = fopen("plaintext2.txt", "w");
    
    decryptCaesar(fr, fw, shift);
    
    fclose(fr);
    fclose(fw);
    
    return 0;
}

Vigenèrova šifra

Vigenèrova šifra je veľmi podobná Cézarovej; posun už ale nie je konštantný a realizuje sa podľa kľúča.

• Kľúčom je reťazec zložený z písmen A až Z, pričom tieto predstavujú posuny o 0 až 25 pozícií v abecede.
• Pri šifrovaní aj dešifrovaní sa jednotlivé abecedné posuny realizujú podľa kľúča. Prvý symbol otvoreného textu je tak zašifrovaný podľa prvého symbolu kľúča, druhý symbol podľa druhého symbolu kľúča, atď. Po vyčerpaní celého kľúča sa pokračuje cyklicky, opäť od jeho začiatku.

Zašifrovanie súboru realizuje nasledujúci program:

#include <cstdio>

const int maxKeyLength = 100;

void encryptVigenere(FILE *fr, FILE *fw, char *key) {
    int c;
    int i = 0;
    while ((c = getc(fr)) != EOF) {
        if ((c >= 'A') && (c <= 'Z')) {
            c = c + (key[i] - 'A');
            if (c > 'Z') {
                c -= 26;
            }
            i++;
        } else if ((c >= 'a') && (c <= 'z')) {
            c = c + (key[i] - 'A');
            if (c > 'z') {
                c -= 26;
            }
            i++;
        }
        if (key[i] == 0) {
            i = 0;
        }
        putc(c, fw);
    }
}

int main(void) {
    char key[maxKeyLength];
    scanf("%s", key);
    
    FILE *fr = fopen("plaintext.txt", "r");
    FILE *fw = fopen("ciphertext.txt", "w");
    
    encryptVigenere(fr, fw, key);
    
    fclose(fr);
    fclose(fw);

    return 0;
}

Dešifrovanie súboru zašifrovaného Vigenèrovou šifrou realizuje tento program:

#include <cstdio>
#include <cassert>

const int maxKeyLength = 100;

void decryptVigenere(FILE *fr, FILE *fw, char *key) {
    int c;
    int i = 0;
    while ((c = getc(fr)) != EOF) {
        if ((c >= 'A') && (c <= 'Z')) {
            c = c - (key[i] - 'A');
            if (c < 'A') {
                c += 26;
            }
            i++;
        } else if ((c >= 'a') && (c <= 'z')) {
            c = c - (key[i] - 'A');
            if (c < 'a') {
                c += 26;
            }
            i++;
        }
        if (key[i] == 0) {
            i = 0;
        }
        putc(c, fw);
    }
}

int main(void) {
    char key[maxKeyLength];
    scanf("%s", key);
    
    FILE *fr = fopen("ciphertext.txt", "r");
    FILE *fw = fopen("plaintext2.txt", "w");
    
    decryptVigenere(fr, fw, key);
    
    fclose(fr);
    fclose(fw);
    
    return 0;
}

Prednáška 17

Oznamy

• Dnes o 18:10 bude v miestnosti A druhá písomka.

Binárne súbory

Textové súbory sú v praxi často nepostačujúcim formátom na ukladanie dát. Ich nevýhody sú napríklad nasledujúce:

• Aj číselné dáta sú v textovom súbore uložené ako postupnosti znakov, čoho dôsledkom je plytvanie pamäťou a pomalé čítanie a zápis (v dôsledku nutnosti konvertovať reťazce na čísla a opačne).
• Pri zápise reálnych čísel môže dochádzať k strate presnosti.
• Pri zápise štruktúr alebo polí je nutné vymyslieť formát ich textovej reprezentácie a naprogramovať funkcie realizujúce ich načítanie a zápis.
• ...

Alternatívnym riešením je použitie binárnych súborov, do ktorých sa namiesto textovej reprezentácie dát ukladá priamo postupnosť bytov zodpovedajúca reprezentácii týchto dát v pamäti počítača. Napríklad 4-bytová premenná typu int s hodnotou 2000000000 sa tak v binárnom súbore reprezentuje 4 bytmi, kým v textovom súbore by bol nutný jeden byte pre každý znak (čiže dohromady 10 bytov) a pravdepodobne aj nejaký oddeľovač od ďalších dát, čomu zodpovedá minimálne jeden ďalší byte.

Binárne súbory teda poskytujú vo všeobecnosti pamäťovo aj časovo efektívnejší spôsob ukladania dát. Nevýhodou tohto prístupu však je, že typicky nie je prenositeľný medzi rôznymi architektúrami, operačnými systémami, či kompilátormi. Napísať program, ktorý na ľubovoľnom systéme vytvorí rovnaký binárny súbor, je pomerne zložité – typicky sa na tento účel používajú špecializované knižnice.

Na tomto predmete budeme pracovať len s textovými súbormi. V nasledujúcom sa však pre úplnosť v krátkosti zameriame aj na základy práce s binárnymi súbormi.

Funkcia fwrite

Funkcia

size_t fwrite(const void *p, size_t size, size_t count, FILE *f);

zapíše do súboru, na ktorý ukazuje smerník f, presne count pamäťových úsekov veľkosti size bytov, nachádzajúcich sa v pamäti od adresy p. Výstupom je potom počet reálne zapísaných úsekov. V hlavičke funkcie fwrite sa vyskytujú dva nové prvky:

• Typ size_t je celočíselný typ, ktorý sa používa na meranie veľkosti pamäte (každý index poľa je napríklad určite tohto typu). Je definovaný vo viacerých knižniciach, napríklad aj v cstdio a je prakticky ekvivalentný nezáporným celým číslam.
• Smerník na void je špeciálny smerníkový typ, ktorý slúži ako vyjadrenie toho, že argumentom môže byť smerník ľubovoľného typu.

Aby bolo možné použiť túto funkciu, musí byť súbor f otvorený na zápis v móde wb (b tu znamená binárny súbor).

Príklad: nasledujúci program vytvorí pole pozostávajúce z druhých odmocnín čísel 0 až 99 a toto pole uloží do binárneho súboru binarny.dat. Využíva pritom operátor sizeof, ktorý vracia veľkosť reprezentácie daného typu v bytoch.

#include <cstdio>
#include <cmath>

int main(void) {
    double a[100];
    FILE *f;
    
    for (int i = 0; i <= 99; i++) {
        a[i] = sqrt(i);
    }
    
    f = fopen("binarny.dat", "wb");
    fwrite(a, sizeof(double), 100, f);
    fclose(f);
    
    return 0;
}

Funkcia fread

Funkcia

size_t fread(void *p, size_t size, size_t count, FILE *f);

zo súboru, na ktorý ukazuje smerník f, prečíta count položiek veľkosti size a uloží ich do pamäte od adresy p.

Ak by sme napríklad chceli overiť, že piatym reálnym číslom uloženým v súbore vytvorenom pomocou programu z predchádzajúceho príkladu je skutočne číslo 2, môžeme napríklad do poľa a uložiť prvých 5 položiek zo súboru binarny.dat a skontrolovať prvok a[4]:

#include <cstdio>

int main(void) {
    FILE *f;
    double a[5];

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

Nasledujúce alternatívne riešenie je o niečo pamäťovo efektívnejšie:

#include <cstdio>

int main(void) {
    FILE *f;
    double *x = new double;

    f = fopen("binarny.dat", "rb");
    for (int i = 0; i <= 4; i++) {
        fread(x, sizeof(double), 1, f);
    }
    fclose(f);
    printf("%f\n", *x);
    delete x;
                     
    return 0;
}

Práca so súbormi prostredníctvom knižnice fstream

So súbormi sme pracovali prostredníctvom knižnice cstdio, ktorá je štandardnou knižnicou jazyka C. Druhou možnosťou, ktorú tu iba telegraficky spomenieme, je využitie knižnice fstream. Tá je štandardnou knižnicou jazyka C++ a umožňuje so súbormi pracovať podobne ako s konzolou prostredníctvom knižnice iostream.

Základy tohto prístupu demonštrujeme na príklade programu, ktorý zo súboru vstup.txt prečíta prirodzené číslo N a následne N ďalších čísel. Tieto čísla potom v obrátenom poradí a oddelené medzerami vypíše do súboru vystup.txt.

#include <fstream>
using namespace std;

const int maxN = 100;

int main(void) {
    ifstream input;
    ofstream output;
    
    int N;
    int a[maxN];
    
    input.open("vstup.txt");
    input >> N;
    for (int i = 0; i <= N-1; i++) {
        input >> a[i];
    }
    input.close();
    
    output.open("vystup.txt");
    for (int i = N-1; i >= 0; i--) {
        output << a[i] << " ";
    }
    output.close();
 
    return 0; 
}

Abstraktný dátový typ

Abstraktné dátové typy (ADT) sú abstrakciami dátových štruktúr nezávislými od samotnej implementácie. Zvyčajne bývajú dané prostredníctvom množiny operácií (hlavičiek funkcií), ktoré daný abstraktný dátový typ poskytuje na prácu s dátami používateľovi. Témou 14. prednášky bol napríklad abstraktný dátový typ dynamická množina, ktorý poskytuje tri základné operácie:

• Zistenie príslušnosti prvku do množiny (contains).
• Pridanie prvku do množiny (add).
• Odobranie prvky z množiny (remove).

Jeden abstraktný dátový typ môže byť implementovaný pomocou viacerých dátových štruktúr. Na 14. prednáške bol napríklad abstraktný dátový typ dynamická množina (presnejšie jeho operácie contains a add) implementovaný pomocou neutriedeného poľa, utriedeného poľa, spájaného zoznamu, priameho adresovania a hešovania.

Výhodou abstraktných dátových typov je predovšetkým oddelenie implementácie dátovej štruktúry od programu, ktorý ju používa. Napríklad program pracujúci s dynamickou množinou prostredníctvom funkcií contains, add a remove možno rovnako dobre použiť pri implementácii množiny pomocou neutriedených polí, ako pri jeho implementácii pomocou hešovania.

Témou dnešnej prednášky budú dva nové abstraktné dátové typy: zásobník (angl. stack) a rad alebo front (angl. queue).

Rad a zásobník

Rad (často aj front; angl. queue) a zásobník (angl. stack) sú jednoduché abstraktné dátové typy umožňujúce udržiavať postupnosť nejakých prvkov (typicky môže ísť o úlohy alebo dáta čakajúce na spracovanie). Rad aj zásobník poskytujú funkciu umožňujúcu vložiť do nich používateľom zadaný prvok. Druhou základnou funkciou poskytovanou oboma týmito abstraktnými dátovými typmi je výber jedného prvku z radu resp. zo zásobníka. Rad sa od zásobníka líši najmä správaním tejto druhej operácie.

Rad

Z radu sa zakaždým vyberie ten jeho prvok, ktorý doň bol vložený ako prvý spomedzi jeho aktuálnych prvkov – možno ho tak pripodobniť k radu pri pokladni v obchode. Takáto metóda manipulácie s dátami sa v angličtine označuje skratkou FIFO, podľa first in, first out.

Prvky radu môžu byť ľubovoľného typu. Namiesto konkrétneho typu (ako napríklad int alebo char) tak budeme pracovať so všeobecným typom, ktorý nazveme dataType. Za ten možno dosadiť ľubovoľný konkrétny typ – napríklad int dosadíme za dataType takto:

typedef int dataType;

Pri využití tohto prístupu tak napríklad bude možné získať z radu prvkov typu int rad prvkov typu char zmenou v jedinom riadku programu.

Abstraktný dátový typ pre rad môže poskytovať napríklad tieto operácie (kde queue je názov štruktúry reprezentujúcej rad):

/* Inicializuje prazdny rad */
void init(queue &q);

/* Zisti, ci je rad prazdny */
bool isEmpty(queue &q);

/* Prida prvok item na koniec radu */
void enqueue(queue &q, dataType item);

/* Odoberie prvok zo zaciatku radu a vrati jeho hodnotu */
dataType dequeue(queue &q);

/* Vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q);

/* Uvolni pamat */
void destroy(queue &q);

Zásobník

Zo zásobníka sa naopak zakaždým vyberie ten prvok, ktorý doň bol vložený ako posledný. Táto metóda manipulácie s dátami sa v angličtine označuje skratkou LIFO, podľa last in, first out.

Abstraktný dátový typ pre zásobník tak môže poskytovať napríklad nasledujúce operácie (stack je názov štruktúry reprezentujúcej zásobník a opäť pracujeme s prvkami všeobecného typu dataType):

/* Inicializuje prazdny zasobnik */
void init(stack &s);

/* Zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s);

/* Prida prvok item na vrch zasobnika */
void push(stack &s, dataType item);

/* Odoberie prvok z vrchu zasobnika a vrati jeho hodnotu */
dataType pop(stack &s);

/* Vrati prvok na vrchu zasobnika, ale necha ho v zasobniku */
dataType peek(stack &s);

/* Uvolni pamat */
void destroy(stack &s);

Programy využívajúce rad a zásobník

Bez ohľadu na samotnú implementáciu vyššie uvedených funkcií vieme písať programy, ktoré ich využívajú. Napríklad nasledujúci program pracuje s radom:

#include <iostream>
using namespace std;

typedef int dataType;


/* Sem pride definicia struktury queue a vsetkych potrebnych funkcii. */


int main(void) {
    queue q;
    init(q);
    enqueue(q, 1);
    enqueue(q, 2);
    enqueue(q, 3);
    cout << dequeue(q) << endl;  // Vypise 1
    cout << dequeue(q) << endl;  // Vypise 2
    cout << dequeue(q) << endl;  // Vypise 3
    destroy(q);
    return 0;
}

Podobne nasledujúci program pracuje so zásobníkom:

#include <iostream>
using namespace std;

typedef int dataType;


/* Sem pride definicia struktury stack a vsetkych potrebnych funkcii. */


int main(void) {
    stack s;
    init(s);
    push(s, 1);
    push(s, 2);
    push(s, 3);
    cout << pop(s) << endl;  // Vypise 3
    cout << pop(s) << endl;  // Vypise 2
    cout << pop(s) << endl;  // Vypise 1
    destroy(s);
    return 0;
}

Implementácia zásobníka a radu

Zásobník pomocou poľa

Na úvod implementujeme zásobník pomocou poľa items, ktoré budeme alokovať na fixnú dĺžku maxN (rovnako dobre by sme však mohli použiť aj dynamické pole). Spodok zásobníka pritom bude v tomto poli uložený na pozícii 0 a jeho vrch na pozícii top. V prípade, že je zásobník prázdny, bude hodnota premennej top rovná -1.

#include <cassert>

// ...

const int maxN = 1000;

struct stack {
    dataType *items; // Alokujeme na pole reprezentujuce jednotlive prvky zasobnika.
    int top;         // Index vrchu zasobnika v poli items. Ak je zasobnik prazdny, ma hodnotu -1.
};

/* Inicializuje prazdny zasobnik */
void init(stack &s) {
    s.items = new dataType[maxN];
    s.top = -1; 
}

/* Zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s) {
    return s.top == -1;
}

/* Prida prvok item na vrch zasobnika */
void push(stack &s, dataType item) {
    assert(s.top <= maxN - 2);
    s.top++;
    s.items[s.top] = item;
} 

/* Odoberie prvok z vrchu zasobnika a vrati jeho hodnotu */
dataType pop(stack &s) {
    assert(!isEmpty(s));
    s.top--;
    return s.items[s.top + 1];
}

/* Vrati prvok na vrchu zasobnika, ale necha ho v zasobniku */          
dataType peek(stack &s) {
    assert(!isEmpty(s));
    return s.items[s.top];
}

/* Uvolni pamat */
void destroy(stack &s) {
    delete[] s.items;
}

Rad pomocou poľa

Rad sa od zásobníka líši tým, že prvky sa z neho vyberajú z opačnej strany, než sa doň vkladajú. Keby sa teda prvý prvok radu udržiaval na pozícii 0, museli by sa po každom výbere prvku tie zvyšné posunúť o jednu pozíciu „doľava”, čo je časovo neefektívne. Rad teda implementujeme tak, aby jeho začiatok mohol byť na ľubovoľnej pozícii first poľa items. Pole items pritom budeme chápať ako cyklické – prvky s indexom menším ako first pritom budeme interpretovať ako nasledujúce za posledným prvkom poľa.

#include <cassert>

// ...

const int maxN = 1000;

struct queue {
    dataType *items; // Alokujeme na pole reprezentujuce jednotlive prvky radu.
    int first;       // Index prveho prvku radu v poli items.
    int count;       // Pocet prvkov v rade. 
};

/* Inicializuje prazdny rad */
void init(queue &q) {
    q.items = new dataType[maxN];
    q.first = 0;
    q.count = 0;
}

/* Zisti, ci je rad prazdny */
bool isEmpty(queue &q) {
    return q.count == 0;
}

/* Prida prvok item na koniec radu */
void enqueue(queue &q, dataType item) {
    assert(q.count < maxN);
    int index = (q.first + q.count) % maxN;
    q.items[index] = item;
    q.count++;
} 

/* Odoberie prvok zo zaciatku radu a vrati jeho hodnotu */
dataType dequeue(queue &q) {
    assert(!isEmpty(q));
    dataType result = q.items[q.first];
    q.first = (q.first + 1) % maxN;
    q.count--;
    return result;
}

/* Vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q) {
    assert(!isEmpty(q));
    return q.items[q.first];
}         

/* Uvolni pamat */
void destroy(queue &q) {
    delete[] q.items;
}

Zásobník pomocou spájaného zoznamu

Zásobník teraz interpretujeme pomocou spájaného zoznamu. Narozdiel od implementácie pomocou poľa bude výhodnejšie uchovávať vrch zásobníka ako prvý prvok zoznamu (pri jednosmerne spájaných zoznamoch je totiž jednoduchšie vkladať a odoberať prvky na jeho začiatku).

Výhoda tohto prístupu oproti implementácii pomocou poľa bude spočívať predovšetkým v tom, že maximálny počet prvkov v zásobníku už nebude obmedzený konštantou maxN. Podobný efekt síce možno docieliť použitím dynamického poľa, jeho realokácia je však časovo neefektívna.

#include <cassert>

// ...

struct node {
    dataType data;
    node *next;
};

struct stack {
    node *top; // Smernik na vrch zasobnika (zaciatok spajaneho zoznamu). Ak je zasobnik prazdny, ma hodnotu NULL.
};

/* Inicializuje prazdny zasobnik */
void init(stack &s) {
    s.top = NULL;
}

/* Zisti, ci je zasobnik prazdny */
bool isEmpty(stack &s) {
    return s.top == NULL;
}

/* Prida prvok item na vrch zasobnika */
void push(stack &s, dataType item) {
    node *tmp = new node;
    tmp->data = item;
    tmp->next = s.top;
    s.top = tmp;  
} 

/* Odoberie prvok z vrchu zasobnika a vrati jeho hodnotu */
dataType pop(stack &s) {
    assert(!isEmpty(s));
    dataType result = s.top->data;
    node *tmp = s.top->next;
    delete s.top;
    s.top = tmp;
    return result;
}

/* Vrati prvok na vrchu zasobnika, ale necha ho v zasobniku */          
dataType peek(stack &s) {
    assert(!isEmpty(s));
    return s.top->data;
}

/* Uvolni pamat */
void destroy(stack &s) {
    while (!isEmpty(s)) {
        pop(s);
    }
}

Rad pomocou spájaného zoznamu

Pri implementácii radu pomocou spájaného zoznamu rozšírime spájané zoznamy zo 14. prednášky o smerník last na posledný prvok zoznamu. Bude tak možné jednoducho vkladať prvky na koniec zoznamu, ako aj odoberať prvky zo začiatku zoznamu.

Výhodou oproti implementácii radu pomocou poľa bude, podobne ako pri zásobníkoch, eliminácia obmedzenia na maximálny počet prvkov v rade.

#include <cassert>

// ...

struct node {
    dataType data;
    node *next;
};

struct queue {
    node *first; // Smernik na prvy prvok radu (spajaneho zoznamu). Ak je rad prazdny, ma hodnotu NULL.
    node *last;  // Smernik na posledny prvok radu (spajaneho zoznamu). Ak je rad prazdny, ma hodnotu NULL.
};

/* Inicializuje prazdny rad */
void init(queue &q) {
    q.first = NULL;
    q.last = NULL;
}

/* Zisti, ci je rad prazdny */
bool isEmpty(queue &q) {
    return q.first == NULL;
}

/* Prida prvok item na koniec radu */
void enqueue(queue &q, dataType item) {
    node *tmp = new node;
    tmp->data = item;
    tmp->next = NULL;
    if (isEmpty(q)) {
        q.first = tmp;
        q.last = tmp;
    } else {
        q.last->next = tmp;
        q.last = tmp;
    }
} 

/* Odoberie prvok zo zaciatku radu a vrati jeho hodnotu */
dataType dequeue(queue &q) {
    assert(!isEmpty(q));
    dataType result = q.first->data;
    node *tmp = q.first->next;
    delete q.first;
    if (tmp == NULL) {
        q.first = NULL; 
        q.last = NULL;
    } else {
        q.first = tmp;
    } 
    return result;
}

/* Vrati prvok zo zaciatku radu, ale necha ho v rade */
dataType peek(queue &q) {
    assert(!isEmpty(q));
    return q.first->data;
}         

/* Uvolni pamat */
void destroy(queue &q) {
    while (!isEmpty(q)) {
        dequeue(q);
    }
}

Použitie zásobníka a radu

Zásobník aj rad často uchovávajú dáta určené na spracovanie, zoznamy úloh, atď. Rad sa zvyčajne používa v prípadoch, keď je žiadúce zachovať ich poradie. Typicky môže ísť o situácie, keď jeden proces generuje úlohy spracúvané iným procesom, napríklad:

• Textový procesor pripravuje strany na tlač a vkladá ich do radu, z ktorého ich tlačiareň (resp. jej ovládač) postupne vyberá.
• Sekvenčne vykonávané výpočtové úlohy čakajú v rade na spustenie.
• Zákazníci čakajú na zákazníckej linke na voľného operátora.
• Pasažieri na standby čakajú na voľné miesto v lietadle.

Zásobník sa, ako o niečo implementačne jednoduchší koncept, zvyčajne používa v situáciách, keď na poradí spracúvania nezáleží, alebo keď je žiadúce vstupné poradie obrátiť. Najvýznamnejší príklad situácie druhého typu je nasledujúci:

• Operačný systém ukladá lokálne premenné volaných funkcií na tzv. zásobníku volaní (angl. call stack), čo umožňuje používanie rekurzie.
• Rekurzívne programy sa dajú prepísať na nerekurzívne pomocou „ručne vytvoreného” zásobníka (na budúcej prednáške si ako príklad ukážeme nerekurzívnu verziu triedenia Quick Sort).

Príklad: kontrola uzátvorkovania

Ako jednoduchý príklad na použitie zásobníka uvažujme nasledujúcu situáciu: na vstupe je daný reťazec pozostávajúci (okrem prípadných ďalších znakov, ktoré možno ignorovať) zo zátvoriek (,),[,],{,}. Úlohou je zistiť, či je tento reťazec dobre uzátvorkovaný. To znamená, že:

• Pre každú uzatváraciu zátvorku musí byť posledná dosiaľ neuzavretá otváracia zátvorka rovnakého typu, pričom musí existovať aspoň jedna dosiaľ neuzavretá zátvorka.
• Každá otváracia zátvorka musí byť niekedy neskôr uzavretá.

Príklady očakávaného vstupu a výstupu:

()
Retazec je dobre uzatvorkovany

nejaky text bez zatvoriek
Retazec je dobre uzatvorkovany

[((({}[])[]))]()
Retazec je dobre uzatvorkovany

[[#))
Retazec nie je dobre uzatvorkovany

())(
Retazec nie je dobre uzatvorkovany

((
Retazec nie je dobre uzatvorkovany

((cokolvek
Retazec nie je dobre uzatvorkovany

Túto úlohu rieši nasledujúci program, ktorý postupne prechádza cez vstupný reťazec, pričom pre každú otváraciu zátvorku si na zásobník pridá uzatváraciu zátvorku rovnakého typu. Ak narazí na uzatváraciu zátvorku, výraz môže byť dobre uzátvorkovaný len v prípade, že je na zásobníku aspoň jedna zátvorka, pričom zátvorka na vrchu zásobníka sa zhoduje so zátvorkou na vstupe. V prípade úspešného prechodu cez celý vstup je reťazec dobre uzátvorkovaný práve vtedy, keď na zásobníku nezostala žiadna zátvorka.

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

typedef char dataType;

/* Sem pride definicia struktury stack a vsetkych potrebnych funkcii. */

int main(void) {
    char vyraz[100];
    cin.getline(vyraz, 100);
    
    stack s;
    init(s);
    
    bool dobre = 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)) {
                    dobre = false;
                } else {
                    char c = pop(s);
                    if (c != vyraz[i]) {
                        dobre = false;
                    }
                }
                break;
        }
    }
    
    dobre = dobre && isEmpty(s);
        
    destroy(s);
    
    if (dobre) {
        cout << "Retazec je dobre uzatvorkovany." << endl;
    } else {
        cout << "Retazec nie je dobre uzatvorkovany." << endl;
    }
    
    return 0;
}

Cvičenie: Prepíšte program na kontrolu zátvoriek do rekurzívnej podoby. Použite pritom iba premenné typu char; špeciálne nepoužívajte žiadne polia. Reťazec načítavajte pomocou funkcií getc a ungetc. Môžete predpokladať, že je ukončený koncom riadku.

Prednáška 18

Oznamy

• Dnes do 22:00 treba odovzdať tretiu domácu úlohu.

Príklad na použitie zásobníka: nerekurzívny Quick Sort

Pripomeňme si triedenie Quick Sort z 11. prednášky:

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

int partition(int a[], int low, int high) {
    int pivot = a[low];
    int lastSmaller = low;
    
    for (int unknown = low + 1; unknown <= high; unknown++) {
        if (a[unknown] < pivot) {
            lastSmaller++;
            swap(a[unknown], a[lastSmaller]);
        }
    }   
    swap(a[low],a[lastSmaller]); 
    return lastSmaller;
}

void quicksort(int a[], int low, int high) {
    if (low >= high) {
        return;
    }
    
    int mid = partition(a, low, high);
        
    quicksort(a, low, mid-1);
    quicksort(a, mid+1, high);   
}

int main(void) {
  // ...
  quicksort(a, 0, N-1);
  // ...
}

Namiesto rekurzie môžeme použiť aj zásobník úsekov, ktoré ešte treba dotriediť.

struct usek {
    int low;
    int high;
};

typedef usek dataType;

/* Sem pride definicia struktury stack a vsetkych potrebnych funkcii. */

/* Sem pridu funkcie swap a partition rovnake ako vyssie. */

void quicksort(int a[], int n) {
    stack s;
    init(s);
    
    usek u;
    u.low = 0;
    u.high = n-1;
    push(s,u);
    
    while (!isEmpty(s)) {
        u = pop(s);
        if (u.low >= u.high) {
            continue;
        }
        
        int mid = partition(a, u.low, u.high);
        
        usek u1;
        u1.low = u.low;
        u1.high = mid-1;
        usek u2;
        u2.low = mid+1;
        u2.high = u.high;
        push(s,u2);
        push(s,u1);
    }
    
    destroy(s);
}

int main(void) {
  // ...
  quicksort(a, N);
  // ...
}

Tento program triedi úseky v rovnakom poradí, ako rekurzívny Quicksort, lebo po rozdelení poľa na dve časti dá na vrch zásobníka úsek zodpovedajúci jeho ľavej časti. Až keď sa táto ľavá časť a všetky podúlohy, ktoré z nej vzniknú, spracuje, dôjde na spracovanie pravej časti poľa. Pri triedení Quick Sort však na tomto poradí nezáleží, takže by sme mohli jednotlivé úseky vkladať na zásobník aj v opačnom poradí.

Na zamyslenie: ako by mohla vyzerať nerekurzívna verzia triedenia Merge Sort? Prečo sa nedá použiť rovnaký prístup ako pri triedení Quick Sort?

Vyfarbovanie súvislých oblastí

Uvažujme obrazec daný obdĺžnikovou maticou o m riadkoch a n stĺpcoch. Obdĺžnikové plátno je v takom prípade rozdelené na m krát n „štvorčekov” určitej konštantnej veľkosti, pričom jednotlivé prvky matice zodpovedajú farbám jednotlivých týchto štvorčekov. V našom jednoduchom príklade budeme pracovať iba s piatimi farbami, ktoré budeme reprezentovať číslami 0,..,4 podľa nasledujúceho poľa (napríklad číslo 0 teda reprezentuje bielu farbu):

const char *farby[5] = {"white", "blue", "black", "yellow", "red"};

Napríklad obrazec

tak môže byť reprezentovaný nasledujúcim textovým súborom obsahujúcim najprv rozmery matice (čísla m a n) a za nimi samotné prvky matice:

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

Zameriame sa teraz na nasledujúci problém: používateľ zvolí (zadá na konzolu) súradnice niektorého „štvorčeka” a cieľom je ofarbiť nejakou farbou (napríklad červenou) celú súvislú oblasť rovnakej farby obsahujúcu daný štvorček. Napríklad pre obrazec vyššie a vstupné súradnice (2,1) – to znamená pre „štvorček” v treťom riadku a druhom stĺpci, keďže matica sa bude indexovať od nuly – by mal byť výstupom nasledujúci obrazec:

Podobný problém je napríklad často potrebné riešiť v rôznych nástrojoch na prácu s grafikou (kde sa namiesto „štvorčekov” ofarbujú pixely) a podobne.

Základ programu

Funkciu na vyfarbovanie súvislých oblastí budeme dorábať do nasledujúcej kostry programu, ktorá obsahuje funkcie na inicializáciu matice, jej načítanie zo súboru, vykresľovanie jednotlivých štvorčekov a celej matice, ako aj uvoľnenie pamäte. Všetky tieto funkcie pracujú podobne ako pri príklade s výškovou mapou z prednášky č. 13. Nasledujúca kostra tiež obsahuje funkciu main, ktorá načíta maticu zo súboru vstup.txt a následne zatiaľ len vykreslí ňou reprezentovaný obrazec do súboru matica.svg.

#include "SVGdraw.h"
#include <cstdio>
#include <cassert>

const char *farby[5] = {"white", "blue", "black", "yellow", "red"}; 

const int stvorcek = 40;    // velkost stvorceka v pixeloch
const int hrubkaCiary = 2;  // hrubka ciary v pixeloch

/* Vytvori maticu s n riadkami a m stlpcami. */
int **vytvorMaticu(int m, int n) {
    int **a;
    a = new int *[m];
    for (int i = 0; i <= m - 1; i++) {
        a[i] = new int[n];
    }
    return a;
}

/* Uvolni pamat matice a s n riadkami a m stlpcami. */
void zmazMaticu(int m, int n, int **a) {
    for (int i = 0; i <= m - 1; i++) {
        delete[] a[i];
    }
    delete[] a;
}

/* Vykresli stvorcek v riadku i a stlpci j s farbou vyplne farba a farbou ciary farbaCiary. */
void vykresliStvorcek(int i, int j, const char *farba, const char *farbaCiary, SVGdraw &drawing) {
    drawing.setLineColor(farbaCiary);
    drawing.setLineWidth(hrubkaCiary);
    drawing.setFillColor(farba);
    drawing.drawRectangle(j * stvorcek, i * stvorcek, stvorcek, stvorcek);
}

/* Vykresli maticu a s n riadkami a m stlpcami. */
void vykresliMaticu(int m, int n, int **a, SVGdraw &drawing) {
    for (int i = 0; i <= m - 1; i++) {
        for (int j = 0; j <= n - 1; j++) {
            vykresliStvorcek(i, j, farby[a[i][j]], "lightgray", drawing);
        }
    }
}

/* Nacita z textoveho suboru, na ktory ukazuje fr, prvky matice a s n riadkami a m stlpcami. */
void nacitajMaticu(FILE *fr, int m, int n, int **a) {
    assert(fr != NULL);
    for (int i = 0; i <= m - 1; i++) {
        for (int j = 0; j <= n - 1; j++) {
            fscanf(fr, "%d", &a[i][j]);
        }
    }
}

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    assert(fr != NULL);
    int m, n;
    fscanf(fr, "%d", &m);               // nacitaj rozmery matice
    fscanf(fr, "%d", &n);
    int **a = vytvorMaticu(m, n);
    nacitajMaticu(fr, m, n, a);         // nacitaj jednotlive prvky matice
    fclose(fr);
        
    SVGdraw drawing(n * stvorcek, m * stvorcek, "matica.svg");
    vykresliMaticu(m, n, a, drawing);

    drawing.finish();
    zmazMaticu(m, n, a);
    
    return 0;
}

Rekurzívne vyfarbovanie

Vyfarbovanie súvislých oblastí potom môžeme realizovať napríklad nasledujúcou rekurzívnou funkciou vyfarbi, ktorá vždy na cieľovú farbu farba prefarbí políčko so súradnicami (riadok, stlpec) a následne sa rekurzívne zavolá pre všetkých susedov tohto políčka, ktoré sú zafarbené pôvodnou farbou prefarbovanej oblasti.

Za každým vyfarbením „štvorčeka” navyše voláme funkciu drawing.wait s parametrom pauza, čo je konštanta, ktorú na úvod nastavíme na 0,3 sekundy. Výsledný SVG súbor tak bude obsahovať animáciu postupného vyfarbovania jednotlivých políčok. Farbou „rámika” okolo políčka budeme navyše rozlišovať, či už bolo dané políčko úplne spracované (t. j. či sa už ukončilo rekurzívne volanie funkcie vyfarbi pre toto políčko).

const double pauza = 0.3;   // pauza po kazdom kroku vysvetlovania v sekundach

/* Prefarbi suvislu jednofarebnu oblast obsahujucu poziciu (riadok,stlpec) na farbu s cislom farba. */
void vyfarbi(int m, int n, int **a, int riadok, int stlpec, int farba, SVGdraw &drawing) {
    int staraFarba = a[riadok][stlpec];
    if (staraFarba == farba) {
        return;
    }
    a[riadok][stlpec] = farba;
    vykresliStvorcek(riadok, stlpec, farby[farba], "brown", drawing);
    drawing.wait(pauza);
    if (riadok - 1 >= 0 && a[riadok - 1][stlpec] == staraFarba) {
        vyfarbi(m, n, a, riadok - 1, stlpec, farba, drawing);
    }
    if (riadok + 1 <= m - 1 && a[riadok + 1][stlpec] == staraFarba) {
        vyfarbi(m, n, a, riadok + 1, stlpec, farba, drawing);
    }
    if (stlpec - 1 >= 0 && a[riadok][stlpec - 1] == staraFarba) {
        vyfarbi(m, n, a, riadok, stlpec - 1, farba, drawing);
    }
    if (stlpec + 1 <= n - 1 && a[riadok][stlpec + 1] == staraFarba) {
        vyfarbi(m, n, a, riadok, stlpec + 1, farba, drawing);
    }
    vykresliStvorcek(riadok, stlpec, farby[farba], "lightgray", drawing);
    drawing.wait(pauza);
}

Funkcia main potom môže vyzerať napríklad nasledovne:

int main(void) {
    FILE *fr = fopen("vstup.txt", "r");
    assert(fr != NULL);
    int m, n;
    fscanf(fr, "%d", &m);               // nacitaj rozmery matice
    fscanf(fr, "%d", &n);
    int **a = vytvorMaticu(m, n);
    nacitajMaticu(fr, m, n, a);         // nacitaj jednotlive prvky matice
    fclose(fr);
        
    SVGdraw drawing(n * stvorcek, m * stvorcek, "matica.svg");
    vykresliMaticu(m, n, a, drawing);

    int riadok, stlpec;
    scanf("%d", &riadok);
    scanf("%d", &stlpec);

    vyfarbi(m, n, a, riadok, stlpec, 4, drawing);

    drawing.finish();
    zmazMaticu(m, n, a);
    
    return 0;
}

• Výsledná animácia

Počítanie ostrovov

Obrazec, s ktorým sme pracovali vyššie, môže reprezentovať napríklad jednoduchú mapu súostrovia, kde more je znázornené modrou farbou a pevnina je znázornená žltou farbou. Úlohou môže byť zistiť počet ostrovov. Ten môžeme zistiť napríklad takto:

• Prechádzame postupne všetky políčka mapy.
• Ak narazíme na pevninu (t. j. žlté políčko), zvýšime doposiaľ nájdený počet ostrovov o 1 a ofarbíme celý ostrov (napríklad) na červeno.
• Ak narazíme na ďalšie žlté políčko, opäť urobíme to isté.
• Toto robíme, až kým prejdeme cez všetky políčka mapy.

Príklad mapy a jej zobrazenie pred začiatkom hľadania ostrovov, po nájdení prvých troch ostrovov a po nájdení všetkých ostrovov:

11 17
 1 1 1 1 1 1 3 1 1 1 1 1 1 1 1 1 1
 1 1 1 3 3 3 3 1 1 3 1 1 1 1 3 3 1
 1 1 1 3 3 1 1 1 1 1 1 1 1 1 3 3 1
 1 1 3 3 1 1 1 1 1 3 3 1 3 3 3 3 1
 1 1 1 3 3 1 1 1 1 3 1 1 3 3 3 3 1
 1 3 3 3 3 1 3 3 1 3 3 1 3 3 3 3 1
 1 1 3 3 1 1 1 3 1 1 1 1 1 1 1 1 1
 1 1 1 1 1 1 1 3 3 3 1 1 3 3 3 1 1
 1 1 1 1 1 1 1 3 3 3 1 1 3 1 3 1 1
 1 1 3 3 3 3 1 3 1 1 1 1 3 3 3 1 1
 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

• 
• 
• 

Do programu z vyššia teda dorobíme funkciu

int najdiOstrovy(int m, int n, int **a, SVGdraw &drawing) {
    int ostrovov = 0;
    for (int i = 0; i <= m - 1; i++) {
        for (int j = 0; j <= n - 1; j++) {
            if (a[i][j] == 3) {
                ostrovov++;
                vyfarbi(m, n, a, i, j, 4, drawing);
            }
        }
    }
    return ostrovov;
}

a funkciu main môžeme zmeniť napríklad takto:

int main(void) {
    FILE *fr = fopen("ostrovy.txt", "r");
    assert(fr != NULL);
    int m, n;
    fscanf(fr, "%d", &m);
    fscanf(fr, "%d", &n);
    int **a = vytvorMaticu(m, n);
    nacitajMaticu(fr, m, n, a);
    fclose(fr);
        
    SVGdraw drawing(n * stvorcek, m * stvorcek, "mapa.svg");
    vykresliMaticu(m, n, a, drawing);

    int pocetOstrovov = najdiOstrovy(m, n, a, drawing);
    printf("Pocet ostrovov je %d.\n", pocetOstrovov);

    drawing.finish();
    zmazMaticu(m, n, a);
    
    return 0;
}

• Výsledná animácia

Cvičenie: upravte funkciu najdiOstrovy tak, aby ešte navyše zistila, či má niektorý z ostrovov jazero.

Vyfarbovanie s použitím zásobníka

S použitím niektorej implementácie zásobníka z minulej prednášky môžeme napísať aj nerekurzívnu verziu funkcie vyfarbi. Tá zakaždým vyberie zo zásobníka niektoré políčko. Ak ešte nebolo ofarbené, ofarbí ho a vloží na zásobník všetkých jeho susedov, ktorých je ešte potrebné ofarbiť.

Drobnou zmenou bude, že súradnice jednotlivých susedov budeme počítať s použitím cyklu for a polí deltaStlpec a deltaRiadok, ktoré pre i = 0,1,2,3 obsahujú posuny jednotlivých súradníc i-teho suseda oproti práve spracúvanému políčku.

struct policko {
    int riadok, stlpec;
};

typedef policko dataType;


/* Sem pride definicia struktury pre zasobnik a funkcii poskytovanych zasobnikom. */


const int deltaRiadok[4] = {0, 0, 1, -1};
const int deltaStlpec[4] = {1, -1, 0, 0};

/* Prefarbi suvislu jednofarebnu oblast obsahujucu poziciu (riadok,stlpec) na farbu s cislom farba. */  
void vyfarbi(int m, int n, int **a, int riadok, int stlpec, int farba, SVGdraw &drawing) {
    int staraFarba = a[riadok][stlpec];
    if (staraFarba == farba) {
        return;
    }
    
    stack s;
    init(s);
    
    policko p;
    p.riadok = riadok;
    p.stlpec = stlpec;
    push(s, p);
    
    while (!isEmpty(s)) {
        p = pop(s);
        if (a[p.riadok][p.stlpec] == farba) {
            continue;
        }
        a[p.riadok][p.stlpec] = farba;
        vykresliStvorcek(p.riadok, p.stlpec, farby[farba], "lightgrey", drawing);
        drawing.wait(pauza);
        for (int i = 0; i <= 3; i++) {
            policko sused;
            sused.riadok = p.riadok + deltaRiadok[i];
            sused.stlpec = p.stlpec + deltaStlpec[i];
            if (sused.riadok >= 0 && sused.riadok <= m - 1 && sused.stlpec >= 0 && sused.stlpec <= n - 1 &&
                    a[sused.riadok][sused.stlpec] == staraFarba) {
                push(s, sused);    
            }        
        }
    }
    destroy(s);
}

• Výsledná animácia

Vyfarbovanie s použitím radu

Namiesto zásobníka môžeme použiť aj rad – obrazec sa potom bude vyfarbovať v poradí podľa vzdialenosti od počiatočného políčka. Pôjde o takzvané prehľadávanie do šírky, kým rekurzívna verzia a verzia so zásobníkom zodpovedajú takzvanému prehľadávaniu do hĺbky.

struct policko {
    int riadok, stlpec;
};

typedef policko dataType;


/* Sem pride definicia struktury pre rad a funkcii poskytovanych radom. */


const int deltaRiadok[4] = {0, 0, 1, -1};
const int deltaStlpec[4] = {1, -1, 0, 0};

/* Prefarbi suvislu jednofarebnu oblast obsahujucu poziciu (riadok,stlpec) na farbu s cislom farba. */  
void vyfarbi(int m, int n, int **a, int riadok, int stlpec, int farba, SVGdraw &drawing) {
    int staraFarba = a[riadok][stlpec];
    if (staraFarba == farba) {
        return;
    }
    
    queue q;
    init(q);
    
    policko p;
    p.riadok = riadok;
    p.stlpec = stlpec;
    enqueue(q, p);
    
    while (!isEmpty(q)) {
        p = dequeue(q);
        if (a[p.riadok][p.stlpec] == farba) {
            continue;
        }
        a[p.riadok][p.stlpec] = farba;
        vykresliStvorcek(p.riadok, p.stlpec, farby[farba], "lightgrey", drawing);
        drawing.wait(pauza);
        for (int i = 0; i <= 3; i++) {
            policko sused;
            sused.riadok = p.riadok + deltaRiadok[i];
            sused.stlpec = p.stlpec + deltaStlpec[i];
            if (sused.riadok >= 0 && sused.riadok <= m - 1 && sused.stlpec >= 0 && sused.stlpec <= n - 1 &&
                    a[sused.riadok][sused.stlpec] == staraFarba) {
                enqueue(q, sused);    
            }        
        }
    }
    destroy(q);
}

• Výsledná animácia

Program potom môžeme upraviť aj tak, aby do každého ofarbeného políčka vypísal jeho vzdialenosť od počiatočného políčka:

struct policko {
    int riadok, stlpec, vzd;
};

typedef policko dataType;


/* Sem pride definicia struktury pre rad a funkcii poskytovanych radom. */


void vypisVzdialenost(int i, int j, int vzd, const char *farbaTextu, SVGdraw &drawing) {
    drawing.setLineColor(farbaTextu);
    drawing.setFontSize(20);
    char text[15];
    sprintf(text, "%d", vzd);
    drawing.drawText((j + 0.5) * stvorcek, (i + 0.5) * stvorcek, text);
}

const int deltaRiadok[4] = {0, 0, 1, -1};
const int deltaStlpec[4] = {1, -1, 0, 0};

/* Prefarbi suvislu jednofarebnu oblast obsahujucu poziciu (riadok,stlpec) na farbu s cislom farba. */  
void vyfarbi(int m, int n, int **a, int riadok, int stlpec, int farba, SVGdraw &drawing) {
    int staraFarba = a[riadok][stlpec];
    if (staraFarba == farba) {
        return;
    }
    
    queue q;
    init(q);
    
    policko p;
    p.riadok = riadok;
    p.stlpec = stlpec;
    p.vzd = 0;
    enqueue(q, p);
    
    while (!isEmpty(q)) {
        p = dequeue(q);
        if (a[p.riadok][p.stlpec] == farba) {
            continue;
        }
        a[p.riadok][p.stlpec] = farba;
        vykresliStvorcek(p.riadok, p.stlpec, farby[farba], "lightgrey", drawing);
        vypisVzdialenost(p.riadok, p.stlpec, p.vzd, "white", drawing);
        drawing.wait(pauza);
        for (int i = 0; i <= 3; i++) {
            policko sused;
            sused.riadok = p.riadok + deltaRiadok[i];
            sused.stlpec = p.stlpec + deltaStlpec[i];
            sused.vzd = p.vzd + 1;
            if (sused.riadok >= 0 && sused.riadok <= m - 1 && sused.stlpec >= 0 && sused.stlpec <= n - 1 &&
                    a[sused.riadok][sused.stlpec] == staraFarba) {
                enqueue(q, sused);    
            }        
        }
    }
    destroy(q);
}

• Výsledná animácia

Prednáška 19

Oznamy

• Boli stanovené predbežné termíny skúšok.
• Podrobné informácie o skúške budú na prednáške 11. decembra.
• Bola zverejnená štvrtá domáca úloha, ktorú treba odovzdať do piatku 13. decembra, 22:00.

Aritmetické výrazy

Nejaký čas sa teraz budeme venovať spracovaniu aritmetických výrazov pozostávajúcich z reálnych čísel, operácií +,-,*,/ a zátvoriek (,). Prakticky najdôležitejšou úlohou tu je vyhodnotenie daného výrazu; napríklad pre výraz

(65 – 3 * 5) / (2 + 3)

chceme vedieť povedať, že jeho hodnota je 10. K tejto úlohe sa však dostaneme až časom. Najprv zavedieme a zľahka preskúmame dva alternatívne spôsoby zápisu aritmetických výrazov, z ktorých jeden nám vyhodnocovanie výrazov značne uľahčí.

Infixová notácia

Bežný spôsob zápisu aritmetických výrazov v matematike sa zvykne nazývať aj infixovou notáciou (prípadne infixovou formou alebo infixovým zápisom). Toto pomenovanie odkazuje na skutočnosť, že binárne operátory (ako napríklad +,-,*,/) sa v tejto notácii píšu medzi svojimi dvoma operandmi. Poradie vykonávania jednotlivých operácií sa pritom riadi zátvorkami a prioritou operácií.

Napríklad

(65 – 3 * 5) / (2 + 3)

je infixový výraz s hodnotou 10.

Prefixová notácia

Pri takzvanej prefixovej notácii (často podľa jej pôvodcu Jana Łukasiewicza nazývanej aj poľskou notáciou) sa každý operátor v aritmetickom výraze zapisuje pred svojimi dvoma operandmi.

Napríklad výraz (65 – 3 * 5) / (2 + 3) má prefixový zápis

/ - 65 * 3 5 + 2 3

Postfixová notácia

Pri postfixovej notácii (často nazývanej aj obrátenou poľskou notáciou) je situácia opačná: operátor sa zapisuje bezprostredne za svojimi dvoma operandmi.

Výraz (65 – 3 * 5) / (2 + 3) má teda postfixový zápis

65 3 5 * - 2 3 + /

Postfixová a prefixová notácia sú pre človeka o niečo ťažšie čitateľné, než bežná notácia infixová (čo môže byť aj otázkou zvyku). Uvidíme však, že najmä výrazy v postfixovej notácii sa dajú pomerne jednoducho vyhodnocovať. Postfixová a prefixová notácia majú oproti infixovej notácii ešte jednu výhodu – nepotrebujú zátvorky.

Nevýhodou naopak je, že tieto notácie nie sú konštruované na používanie unárneho operátora -. Ľahko napríklad vidieť, že prefixový výraz - - 2 3 by mohol zodpovedať ako výrazu -2 - 3, tak aj výrazu -(2 - 3). V nasledujúcom teda budeme predpokladať, že výrazy neobsahujú unárne mínus. Tento nedostatok nie je nijak závažný – každý infixový podvýraz typu -cokolvek možno totiž ekvivalentne prepísať ako (0 - 1) * cokolvek. (Alternatívne by sme v prefixových a postfixových výrazoch mohli pre unárne mínus zaviesť nejaký nový symbol.)

Vyhodnocovanie aritmetických výrazov v postfixovej notácii

Na vyhodnocovanie výrazov v postfixovej forme budeme používať zásobník, do ktorého budeme postupne vkladať jednotlivé operandy. Využijeme pritom vlastnosť, že operátor má v postfixovom zápise obidva operandy pred sebou. Keď teda narazíme na operátor, jeho operandy sme už prečítali a spracovali. Ide navyše o posledné dve prečítané alebo vypočítané hodnoty.

Výraz budeme postupne čítať zľava doprava:

• Keď pritom narazíme na operand, vložíme ho na zásobník.
• Keď narazíme na operátor:
  • Vyberieme zo zásobníka jeho dva operandy.
  • Prvé z týchto čísel je pritom druhým operandom a druhé z nich je prvým operandom.
  • Vykonáme s týmito operandmi danú operáciu a výsledok tejto operácie vložíme naspäť na zásobník.
• Tento postup opakujeme, až kým neprídeme na koniec výrazu. V tom okamihu by sme mali mať na zásobníku jediný prvok – výslednú hodnotu výrazu.

#include <cstdio>
#include <cctype>
#include <cassert>

typedef double dataType;


/* Sem pride definicia struktury pre zasobnik a funkcii poskytovanych zasobnikom. */


int main(void) {
    FILE *fr = stdin;
        
    stack s;
    init(s);
    
    while (true) {
        int c = getc(fr);
        while (c != EOF && c != '\n' && isspace(c)) {
            c = getc(fr);
        }
        if (c == EOF || c == '\n') {
            break;
        } else if (isdigit(c)) {
            ungetc(c, fr);
            double num;
            fscanf(fr, "%lf", &num);
            push(s, num);
        } else {
            double num2 = pop(s);         // druhy operand vyberieme ako prvy ...
            double num1 = pop(s);         // ... a prvy operand ako druhy
            switch (c) {
                case '+':
                    push(s, num1 + num2);
                    break;
                case '-':
                    push(s, num1 - num2);
                    break;
                case '*':
                    push(s, num1 * num2);
                    break;    
                case '/':
                    push(s, num1 / num2);
                    break;    
            }
        }
    }
    
    printf("%lf\n", pop(s));
    assert(isEmpty(s));

    destroy(s);
    return 0;
}

Nasledujúca alternatívna implementácia vyhodnocovania postfixových výrazov sa od predchádzajúcej líši tým, že vstupný výraz najprv uloží do reťazca, ktorý následne vyhodnotí prostredníctvom funkcie evaluatePostfix. Drobnou nevýhodou tohto prístupu je, že dĺžka vstupného reťazca je obmedzená konštantou; funkcia vyhodnocujúca výraz uložený v reťazci sa nám však neskôr zíde.

#include <cstdio>
#include <cctype>
#include <cassert>

typedef double dataType;


/* Sem pride definicia struktury pre zasobnik a funkcii poskytovanych zasobnikom. */


double evaluatePostfix(char *expr) {
    stack s;
    init(s);
    
    int i = 0;
    while (true) {
        while (expr[i] != 0 && expr[i] != '\n' && isspace(expr[i])) {
            i++;
        }
        if (expr[i] == 0 || expr[i] == '\n') {
            break;
        } else if (isdigit(expr[i])) {
            double num;
            sscanf(&expr[i], "%lf", &num);
            push(s, num);
            while (isdigit(expr[i]) || expr[i] == '.') {
                i++;
            } 
        } else {
            double num2 = pop(s);         // druhy operand vyberieme ako prvy ...
            double num1 = pop(s);         // ... a prvy operand ako druhy
            switch (expr[i]) {
                case '+':
                    push(s, num1 + num2);
                    break;
                case '-':
                    push(s, num1 - num2);
                    break;
                case '*':
                    push(s, num1 * num2);
                    break;    
                case '/':
                    push(s, num1 / num2);
                    break;    
            }
            i++;
        }
    }
    double result = pop(s);
    assert(isEmpty(s));
    destroy(s);
    
    return result;
}

int main(void) {
    FILE *fr = stdin;
        
    char expr[100];    
    fgets(expr, 100, fr);
    printf("%lf\n", evaluatePostfix(expr));    
    
    return 0;
}

Prevod výrazu z infixovej notácie do postfixovej

Oveľa zaujímavejšou a dôležitejšou úlohou, než vyhodnocovanie postfixových výrazov, je vyhodnocovanie výrazov v klasickej infixovej notácii. V nasledujúcom túto úlohu vyriešime tým, že napíšeme program realizujúci prevod aritmetického výrazu z infixovej notácie do postfixovej. Výraz v infixovej notácii teda budeme môcť vyhodnotiť tak, že ho najprv prevedieme do postfixovej notácie a tento postfixový výraz následne vyhodnotíme algoritmom popísaným vyššie. (Elegantnejšie prístupy k vyhodnocovaniu aritmetických výrazov vyžadujú istú dávku teórie, s ktorou sa typický študent informatiky zoznámi vo vyšších ročníkoch štúdia.)

Algoritmus pre infixové výrazy neobsahujúce unárne mínus

Začneme tým, že prevod do postfixovej notácie realizujeme pre infixové výrazy neobsahujúce unárny operátor mínus – ako sme už totiž videli, prítomnosť unárneho mínusu vo výslednom postfixovom výraze by mohla viesť k nejednoznačnostiam.

Uvažujme najprv výrazy bez zátvoriek. Tie pozostávajú z čísel a binárnych operátorov +, -, *, /, kde * a / majú vyššiu prioritu (precedenciu) ako + a -. Všetky tieto operátory sú navyše zľava asociatívne. Na prevod takéhoto jednoduchého výrazu do postfixového tvaru ním teda stačí prejsť zľava doprava a všimnúť si dve skutočnosti:

• Poradie jednotlivých čísel v postfixovom výraze je rovnaké, ako v pôvodnom infixovom výraze.
  • Napríklad výraz 1 + 2 + 3 * 4 - 5 má postfixový tvar 1 2 + 3 4 * + 5 -.
  • Z toho vyplýva, že pri prechádzaní vstupným infixovým výrazom možno čísla priamo vypisovať do výstupného postfixového výrazu bez toho, aby nás ďalej zaujímali.
• Každý operátor treba presunúť spomedzi jeho dvoch argumentov za jeho druhý argument.
  • Ak teda vo vstupnom infixovom výraze narazíme na operátor, nevypíšeme ho hneď do výstupného výrazu, ale uložíme ho pre neskorší výpis na správnej pozícii.
  • Uložený operátor potom treba vypísať za jeho druhým argumentom. Ak pritom aj samotný tento argument obsahuje nejaké ďalšie operátory, určite musia byť vypísané skôr. Operátory teda budeme ukladať na zásobníku.
  • Zakaždým, keď vo vstupnom infixovom výraze narazíme na operátor, je možné, že tesne pred ním končí argument jedného alebo niekoľkých operátorov uložených na zásobníku. Vďaka ľavej asociatívnosti pritom ide o práve všetky operátory na vrchu zásobníka, ktoré majú vyššiu alebo rovnakú prioritu, ako nájdený operátor. Všetky tieto operátory teda postupne vyberieme zo zásobníka a vypíšeme ich do výstupného reťazca. Až následne na zásobník vložíme nájdený operátor.
  • Podobnú činnosť treba vykonať aj na konci vstupného reťazca – v takom prípade musíme vypísať všetky operátory na zásobníku.

Z technických dôvodov budeme na spodku zásobníka uchovávať „umelé dno” #, ktoré budeme chápať ako symbol s nižšou prioritou ako všetky operátory. Situáciu, keď pri vyberaní operátorov zo zásobníka narazíme na jeho dno tak budeme môcť riešiť konzistentne so situáciou, keď narazíme na operátor s nižšou prioritou – v oboch prípadoch chceme s vyberaním prestať.

Na vstupnom výraze 1 + 2 + 3 * 4 - 5 bude práve popísaný algoritmus pracovať nasledovne:

Krok     Vstupný symbol     Výstupný reťazec     Zásobník (dno naľavo)      
------------------------------------------------------------------------------------------------------------------------
   1                  1                          #                         vypíš číslo 1 na výstup 
                            1                    #
   2                  +     1                    #                         # má nižšiu prioritu ako +, nevyberaj ho
                      +     1                    #                         vlož + na zásobník
                            1                    # + 
   3                  2     1                    # +                       vypíš číslo 2 na výstup
                            1 2                  # + 
   4                  +     1 2                  # +                       + má rovnakú prioritu ako +, vyber ho a vypíš
                      +     1 2 +                #                         # má nižšiu prioritu ako +, nevyberaj ho
                      +     1 2 +                #                         vlož + na zásobník
                            1 2 +                # +   
   5                  3     1 2 +                # +                       vypíš číslo 3 na výstup
                            1 2 + 3              # + 
   6                  *     1 2 + 3              # +                       + má nižšiu prioritu ako *, nevyberaj ho
                      *     1 2 + 3              # +                       vlož * na zásobník
                            1 2 + 3              # + *     
   7                  4     1 2 + 3              # + *                     vypíš číslo 4 na výstup
                            1 2 + 3 4            # + *                     
   8                  -     1 2 + 3 4            # + *                     * má vyššiu prioritu ako -, vyber ho a vypíš
                      -     1 2 + 3 4 *          # +                       + má rovnakú prioritu ako -, vyber ho a vypíš
                      -     1 2 + 3 4 * +        #                         # má nižšiu prioritu ako -, nevyberaj ho
                      -     1 2 + 3 4 * +        #                         vlož - na zásobník
                            1 2 + 3 4 * +        # -             
   9                  5     1 2 + 3 4 * +        # -                       vypíš číslo 5 na výstup
                            1 2 + 3 4 * + 5      # -                 
  10    [koniec vstupu]     1 2 + 3 4 * + 5      # -                       vyber a vypíš operátory na zásobníku

                            1 2 + 3 4 * + 5 -    #                         <-- VÝSLEDNÝ POSTFIXOVÝ VÝRAZ
                           

Do tejto schémy je už jednoduché zapracovať aj zátvorky:

• Zakaždým, keď vo vstupnom infixovom reťazci narazíme na ľavú zátvorku, vložíme ju do zásobníka. Podobne ako pri # ju budeme považovať za symbol s nižšou prioritou, než majú všetky binárne operátory (argument operátora spred tejto zátvorky totiž určite nemôže končiť v jej vnútri).
• Keď naopak narazíme na pravú zátvorku, potrebujeme vypísať všetky doposiaľ nevypísané operátory uzatvorené touto zátvorkou. Preto v takom prípade vyberieme a vypíšeme na výstup všetky operátory zo zásobníka až po prvú ľavú zátvorku (ktorú zo zásobníka taktiež vyberieme).

Funkcia infixToPostfix, realizujúca prevod z infixovej do postfixovej notácie, tak môže vyzerať napríklad nasledovne:

#include <cstdio>
#include <cassert>
#include <cctype>

typedef char dataType;


/* Sem pride definicia struktury pre zasobnik a funkcii poskytovanych zasobnikom. */


int precedence(char op) {
    switch (op) {
        case '#':
        case '(':
            return 0;
            break;
        case '+':
        case '-':
            return 1;
            break;
        case '*':
        case '/':
            return 2;
            break;
    }
    return -1;  // specialne pre biele znaky vrati -1
}

/* Skonvertuje infixovy vyraz infix to postfixovej formy a vysledok ulozi do retazca postfix */
void infixToPostfix(const char *infix, char *postfix) {
    stack s;
    init(s);
    push(s, '#');
    
    int j = 0; // index do vystupneho retazca
    for (int i = 0; infix[i] != 0; i++) {
        if (isdigit(infix[i]) || infix[i] == '.') {
            postfix[j++] = infix[i];
        } 
        switch (infix[i]) {
            case '(':
                push(s, '(');
                break;
            case ')': 
                char c;
                while ((c = pop(s)) != '(') {
                    postfix[j++] = ' '; 
                    postfix[j++] = c;
                }
                break;
            default:
                int p = precedence(infix[i]);
                if (p == -1) {                      // predovsetkym biele znaky
                    break;
                }
                postfix[j++] = ' ';
                while (p <= precedence(peek(s))) {
                    postfix[j++] = pop(s);
                    postfix[j++] = ' ';
                }
                push(s, infix[i]);
                break;
        }
    }
    while (!isEmpty(s)) {
        char c = pop(s);
        if (c != '#') {
            postfix[j++] = ' ';
            postfix[j++] = c;
        }
    }
    postfix[j] = 0;
    
    destroy(s);
}

const int maxN = 100;

int main(void) {
    char infix[maxN];
    char postfix[2 * maxN];
    
    fgets(infix, maxN, stdin);
    infixToPostfix(infix, postfix);
    
    printf("Postfixovy tvar vyrazu: %s\n", postfix);
    
    return 0;
}

Cvičenie: Rozšírte program vyššie o operáciu umocňovania ^ s prioritou vyššou ako * (dajte si pritom pozor na fakt, že umocňovanie je narozdiel od operácií +, -, *, / sprava asociatívne).

Rozšírenie na infixové výrazy obsahujúce unárne mínus

Pri prevode infixového výrazu do postfixového tvaru sme predpokladali, že neobsahuje žiadny výskyt unárneho operátora -. V nasledujúcom tento nedostatok napravíme: napíšeme funkciu normalise, ktorá v danom infixovom výraze in nahradí všetky výskyty unárneho mínusu reťazcom (0-1)* a výsledok uloží do (opäť infixového) výrazu out. Mínus je pritom v korektnom infixovom výraze unárny práve vtedy, keď (modulo biele znaky, ktoré budeme ignorovať) nenasleduje za číslom, ani za pravou zátvorkou.

void normalise(const char *in, char *out) {
    int j = 0; // index do vystupneho retazca
    bool hasOperand = false;
    for (int i = 0; in[i] != 0; i++) {
        if (in[i] == '-' && !hasOperand) {
            out[j++] = '(';
            out[j++] = '0';
            out[j++] = '-';
            out[j++] = '1';
            out[j++] = ')';
            out[j++] = '*';
        } else if (isdigit(in[i]) || in[i] == '.' || in[i] == ')') {
            out[j++] = in[i];
            hasOperand = true;
        } else if (isspace(in[i])) {
            out[j++] = in[i];
        } else {
            out[j++] = in[i];
            hasOperand = false;
        }
    }
    out[j] = 0;
}

Prevod infixového výrazu s unárnymi mínusmi do postfixového tvaru teda môžeme realizovať tak, že najprv zavoláme funkciu normalise a následne funkciu infixToPostfix. (O niečo krajším riešením by bolo nahradenie unárnych mínusov nejakým novým špeciálnym znakom – v takom prípade by sa však musela zmeniť aj funkcia infixToPostfix.) Následne môžeme výsledný výraz aj vyhodnotiť pomocou funkcie evaluatePostfix.

const int maxN = 100;

int main(void) {
    char infix1[maxN];
    char infix2[6 * maxN];
    char postfix[12 * maxN];
    
    fgets(infix1, maxN, stdin);
  
    normalise(infix1, infix2);
    printf("Vyraz po odstraneni unarnych minusov: %s\n", infix2);
    
    infixToPostfix(infix2, postfix);
    printf("Vyraz v postfixovom tvare: %s\n", postfix);
    
    printf("Hodnota vyrazu: %lf\n", evaluatePostfix(postfix));
    
    return 0;
}

Pri implementácii uvedeného programu sa však treba mať na pozore: kým totiž funkcia evaluatePostfix využíva zásobník prvkov typu double, funkcia infixToPostfix využíva zásobník prvkov typu char. Pri pokuse o skopírovanie kódu pre zásobník do zdrojového súboru tohto programu tak stojíme pred voľbou medzi

typedef char dataType;

a

typedef double dataType;

V tomto prípade ešte môžeme zvoliť druhú možnosť a za dataType považovať double; o zvyšok sa postará automatické pretypovanie znakov (čiže špeciálnych celých čísel) na reálne čísla a naopak. Toto riešenie má však ďaleko od ideálneho a pre iné dvojice typov nemusí riešenie tohto typu existovať vôbec. (Ozaj elegantný prístup k tomuto problému vyžaduje pokročilejšie programátorské techniky z letného semestra.)

Prednáška 20

Oznamy

• V stredu 11. decembra bude o 18:10 v posluchárni A tretia písomka.

Aritmetické stromy

Strom pre výraz (65 – 3 * 5)/(2 + 3)

Aritmetické výrazy možno reprezentovať aj vo forme stromu nazývaného aj aritmetickým stromom:

• Operátory a čísla tvoria tzv. uzly stromu.
• Operátory tvoria tzv. vnútorné uzly stromu – každý z nich má dvoch synov zodpovedajúcich podvýrazom pre jednotlivé operandy.
• Čísla tvoria tzv. listy aritmetického stromu – tie už nemajú žiadnych synov.
• Strom obsahuje jediný uzol, ktorý nie je synom žiadneho iného uzla – to je tzv. koreň stromu a reprezentuje celý aritmetický výraz.
• Informatici stromy väčšinou kreslia „hore nohami”, s koreňom na vrchu.

Uzol aritmetického stromu tak môžeme reprezentovať napríklad nasledujúcou štruktúrou:

struct treeNode {
    double val;      // ciselna hodnota (zmysluplna len v listoch)
    char op;         // operator (zmysluplny len vo vnutornych uzloch, pre listy vzdy rovny medzere)
    treeNode *left;  // smernik na koren podstromu reprezentujuceho lavy podvyraz
    treeNode *right; // smernik na koren podstromu reprezentujuceho pravy podvyraz
};

Pre vnútorné uzly stromu (zodpovedajúce operátorom) pritom:

• Smerníky left a right budú ukazovať na korene podstromov reprezentujúcich ľavý resp. pravý podvýraz.
• Znak op bude zodpovedať danému operátoru (napríklad '+').
• Hodnota val ostane nevyužitá.

Pre listy (zodpovedajúce číselným hodnotám) naopak:

• Smerníky left a right budú mať hodnotu NULL.
• Znak op bude medzera ' ' (podľa op teda môžeme rozlišovať, či ide o číslo alebo o operátor).
• Vo val bude uložená hodnota daného čísla.

Celý strom pritom budeme reprezentovať jeho koreňom.

Ide tu o jednoduchú, no nie veľmi elegantnú reprezentáciu aritmetických stromov, keďže viaceré položky štruktúry treeNode môžu byť nevyužité. S využitím objektového programovania (letný semester) možno aritmetické stromy reprezentovať omnoho krajšie.

Vytvorenie uzlu aritmetického stromu

Nasledujúce funkcie vytvoria nový vnútorný uzol (pre operátor) resp. nový list (pre číslo):

treeNode *createOp(char op, treeNode *left, treeNode *right) {
    treeNode *v = new treeNode;
    v->left = left;
    v->right = right;
    v->op = op;
    return v; 
}

treeNode *createNum(double val) {
    treeNode *v = new treeNode;
    v->left = NULL;
    v->right = NULL;
    v->op = ' ';
    v->val = val;
    return v;
}

„Ručne” teraz môžeme vytvoriť strom pre výraz (65 – 3 * 5)/(2 + 3):

treeNode *root = createOp('/', 
                   createOp('-', 
                     createNum(65),
                     createOp('*', createNum(3), createNum(5))),
                   createOp('+', createNum(2), createNum(3)));

Alebo po častiach:

treeNode *v65 = createNum(65);
treeNode *v3 = createNum(3);
treeNode *v5 = createNum(5);
treeNode *v2 = createNum(2);
treeNode *v3b = createNum(3);
treeNode *vKrat = createOp('*', v3, v5);
treeNode *vMinus = createOp('-', v65, vKrat);
treeNode *vPlus = createOp('+', v2, v3b);
treeNode *vDeleno = createOp('/', vMinus, vPlus);

Uvoľnenie pamäte

Nasledujúca funkcia uvoľní z pamäte celý strom s koreňom root:

void destroyTree(treeNode *root) {
    if (root != NULL) {
        destroyTree(root->left);
        destroyTree(root->right);
        delete root;
    }
}

Vyhodnotenie výrazu reprezentovaného stromom

Nasledujúca rekurzívna funkcia vypočíta hodnotu aritmetického výrazu reprezentovaného stromom s koreňom root:

double evaluateTree(treeNode *root) {
    assert(root != NULL);
    if (root->op == ' ') {
        return root->val;
    } else {
        double valLeft = evaluateTree(root->left);
        double valRight = evaluateTree(root->right);
        switch (root->op) {
            case '+':
                return valLeft + valRight;
                break;
            case '-':
                return valLeft - valRight;
                break;
            case '*':
                return valLeft * valRight;
                break;
            case '/':
                return valLeft / valRight;
                break;
            default:
                assert(false);
                break;
        }
    }
}

Vypísanie výrazu reprezentovaného stromom v rôznych notáciách

Infixovú, prefixovú, resp. postfixovú reprezentáciu aritmetického výrazu reprezentovaného stromom s koreňom root možno získať pomocou nasledujúcich funkcií:

void printInorder(FILE *fw, treeNode *root) {
    if (root->op == ' ') {
        fprintf(fw, "%.2lf", root->val);
    } else {
        fprintf(fw, "(");
        printInorder(fw, root->left);
        fprintf(fw, " %c ", root->op);
        printInorder(fw, root->right);
        fprintf(fw, ")");
    }
}

void printPreorder(FILE *fw, treeNode *root) {
    if (root->op == ' ') {
        fprintf(fw, "%.2lf ", root->val);
    } else {
        fprintf(fw, "%c ", root->op);
        printPreorder(fw, root->left);
        printPreorder(fw, root->right);
    }
}

void printPostorder(FILE *fw, treeNode *root) {
    if (root->op == ' ') {
        fprintf(fw, "%.2lf ", root->val);
    } else {
        printPostorder(fw, root->left);
        printPostorder(fw, root->right);
        fprintf(fw, "%c ", root->op);
    }
}

Vytvorenie stromu z postfixového výrazu

Pripomeňme si z minulej prednášky funkciu na vyhodnocovanie postfixového výrazu:

typedef double dataType;


/* Sem pride definicia struktury pre zasobnik a vsetkych funkcii poskytovanych zasobnikom. */


double evaluatePostfix(char *expr) {
    stack s;
    init(s);
    
    int i = 0;
    while (true) {
        while (expr[i] != 0 && expr[i] != '\n' && isspace(expr[i])) {
            i++;
        }
        if (expr[i] == 0 || expr[i] == '\n') {
            break;
        } else if (isdigit(expr[i])) {
            double num;
            sscanf(&expr[i], "%lf", &num);
            push(s, num);
            while (isdigit(expr[i]) || expr[i] == '.') {
                i++;
            } 
        } else {
            double num2 = pop(s);         
            double num1 = pop(s);         
            switch (expr[i]) {
                case '+':
                    push(s, num1 + num2);
                    break;
                case '-':
                    push(s, num1 - num2);
                    break;
                case '*':
                    push(s, num1 * num2);
                    break;    
                case '/':
                    push(s, num1 / num2);
                    break;    
            }
            i++;
        }
    }
    double result = pop(s);
    assert(isEmpty(s));
    destroy(s);
    
    return result;
}

Túto funkciu možno jednoducho prepísať tak, aby namiesto vyhodnocovania výrazu konštruovala zodpovedajúci aritmetický strom. Namiesto hodnôt jednotlivých podvýrazov stačí na zásobníku uchovávať korene stromov, ktoré tieto podvýrazy reprezentujú. Aplikácii aritmetickej operácie potom bude zodpovedať „spojenie” dvoch podstromov do jedného stromu:

typedef treeNode *dataType;


/* Sem pride definicia struktury pre zasobnik a vsetkych funkcii poskytovanych zasobnikom. */


treeNode *parsePostfix(char *expr) {
    stack s;
    init(s);
    
    int i = 0;
    while (true) {
        while (expr[i] != 0 && expr[i] != '\n' && isspace(expr[i])) {
            i++;
        }
        if (expr[i] == 0 || expr[i] == '\n') {
            break;
        } else if (isdigit(expr[i])) {
            double num;
            sscanf(&expr[i], "%lf", &num);
            push(s, createNum(num));
            while (isdigit(expr[i]) || expr[i] == '.') {
                i++;
            } 
        } else {
            treeNode *right = pop(s);         
            treeNode *left = pop(s);         
            push(s, createOp(expr[i], left, right));
            i++;
        }
    }
    treeNode *result = pop(s);
    assert(isEmpty(s));
    destroy(s);
    
    return result;
}

Ukážkový program pracujúci s aritmetickými stromami

Nasledujúci program prečíta z konzoly aritmetický výraz v postfixovom tvare, skonštruuje jeho aritmetický strom a následne preň zavolá funkcie na výpočet hodnoty výrazu a jeho výpis v rôznych notáciách:

int main(void) {           
    char expr[100];    
    fgets(expr, 100, stdin);
    treeNode *root = parsePostfix(expr); 

    printf("Hodnota vyrazu je: %.2f\n", evaluateTree(root));
    printf("Vyraz v infixovej notacii: ");
    printInorder(stdout, root);
    printf("\n");
    printf("Vyraz v prefixovej notacii: ");
    printPreorder(stdout, root);
    printf("\n");
    printf("Vyraz v postfixovej notacii: ");
    printPostorder(stdout, root);
    printf("\n");
      
    destroyTree(root);  
      
    return 0;
}

Binárne stromy

Aritmetické stromy sú špeciálnym prípadom binárnych stromov. V informatike nachádzajú binárne stromy množstvo rozličných uplatnení – zameriame sa preto na všeobecnú dátovú štruktúru binárneho stromu. V tomto všeobecnejšom kontexte sa pritom znova objavia niektoré techniky, ktoré sme používali v špeciálnom prípade aritmetických stromov.

Terminológia stromov

Pod stromom budeme rozumieť množinu vrcholov pospájaných hranami tak, aby každá dvojica vrcholov bola spojená práve jednou postupnosťou hrán (vrcholy teda nemôžu byť pospájané cyklicky). Navyše nás na tomto predmete budú zaujímať iba zakorenené stromy, ktoré obsahujú práve jeden špeciálny vrchol nazývaný koreňom. Vždy, keď budeme hovoriť o stromoch, budeme mať na mysli zakorenené stromy. V súvislosti s nimi budeme o vrcholoch väčšinou hovoriť ako o uzloch.

Poznámka. Takáto definícia stromov nie je úplne matematicky presná (ide o „popularizáciu” ozajstnej definície). Poriadne definície pojmov súvisiacich so stromami patria do náplne predmetu Úvod do kombinatoriky a teórie grafov (letný semester).

Každý uzol u zakoreneného stromu okrem koreňa je spojený hranou s práve jedným otcom (alebo rodičom; angl. parent), ktorým je nejaký uzol v (ide o jediný vrchol stromu spojený hranou s uzlom u, ktorý je bližšie ku koreňu, než uzol u). Naopak potom hovoríme, že uzol u je synom (alebo dieťaťom; angl. child resp. son) uzla v. Vo všeobecnom zakorenenom strome pritom môže mať každý uzol ľubovoľný prirodzený (a teda aj nulový) počet synov. Na tomto predmete budeme navyše predpokladať, že pre každý vrchol je dané nejaké úplné usporiadanie jeho synov (možno teda rozlišovať medzi „najľavejším” synom, synom druhým zľava, atď.). Strom je binárny, ak má každý uzol najviac dvoch synov. Budeme pritom rozlišovať medzi pravým a ľavým synom – každý uzol má najviac jedného ľavého a najviac jedného pravého syna.

Na tomto predmete budeme odteraz pod stromom vždy rozumieť zakorenený binárny strom s rozlišovaním medzi pravými a ľavými synmi.

Predkom uzla u nazveme ľubovoľný uzol v rôzny od u ležiaci na nejakej ceste z u do koreňa stromu. Naopak potom hovoríme, že u je potomkom uzla v. Uzly zakoreneného stromu, ktoré nemajú žiadneho syna, nazývame listami; zvyšné uzly potom nazývame vnútornými uzlami.

Podstromom stromu T zakoreneným v nejakom uzle v stromu T budeme rozumieť strom s koreňom v pozostávajúci z uzla v, všetkých jeho potomkov a všetkých hrán stromu T vedúcich medzi týmito uzlami.

Každý binárny strom je teda buď prázdny, alebo je tvorený jeho koreňom a dvoma podstromami – ľavým a pravým.

Štruktúra pre uzol binárneho stromu

V nasledujúcom budeme pracovať výhradne s binárnymi stromami. Štruktúra pre uzol všeobecného binárneho stromu je podobná, ako pri aritmetických stromoch – namiesto operátora alebo hodnoty si však v každom uzle môžeme pamätať hodnotu ľubovoľného typu dataType.

Keďže neskôr budeme binárne stromy vypisovať, budeme predpokladať, že pre hodnoty typu dataType máme k dispozícii funkciu printDataType, ktorá ich v nejakom vhodnom formáte vypisuje. Nasledujúci kus kódu zodpovedá situácii, keď dataType je int.

#include <cstdio>


// ...


/* Typ prvkov ukladanych v uzloch binarneho stromu -- moze byt prakticky lubovolny */
typedef int dataType;          

/* Funkcia pre vypis hodnoty typu dataType */
void printDataType(dataType d) {
    printf("%d ", d);  // pre int
}


// ...


/* Uzol binarneho stromu */
struct node {
    dataType data;  // hodnota ulozena v danom uzle
    node *left;     // smernik na laveho syna (NULL, ak tento syn neexistuje)
    node *right;    // smernik na praveho syna (NULL, ak tento syn neexistuje)
};

Vytvorenie binárneho stromu

Nasledujúca funkcia vytvorí uzol binárneho stromu s dátami data, ľavým podstromom zakoreneným v uzle *left a pravým podstromom zakoreneným v uzle *right (parametre left a right sú teda smerníkmi na uzly). Ako výstup funkcia vráti smerník na novovytvorený uzol.

/* Vytvori uzol binarneho stromu */
node *createNode(dataType data, node *left, node *right) {
    node *v = new node;
    v->data = data;
    v->left = left;
    v->right = right;
    return v;
}

Nasledujúca volanie tak napríklad vytvorí binárny strom so šiestimi uzlami zakorenený v uzle *root.

node *root = createNode(1,
                   createNode(2, 
                     createNode(3, NULL, NULL),
                     createNode(4,NULL,NULL)),
                   createNode(5,
                     NULL, 
                     createNode(6, NULL, NULL)));

Cvičenie: nakreslite binárny strom vytvorený predchádzajúcim volaním.

Likvidácia binárneho stromu

Nasledujúca rekurzívna funkcia zlikviduje celý podstrom zakorenený v uzle *root (t. j. pouvoľňuje pamäť pre všetky jeho uzly).

/* Zlikviduje podstrom s korenom *root (pouvolnuje pamat) */
void destroyTree(node *root) {
    if (root != NULL) {
        destroyTree(root->left);
        destroyTree(root->right);
        delete root;
    }
}

Výška binárneho stromu

Hĺbkou uzla binárneho stromu nazveme jeho vzdialenosť od koreňa. Koreň má teda hĺbku 0, jeho synovia majú hĺbku 1, atď. Výškou binárneho stromu (niekedy nazývanou aj jeho hĺbkou) potom nazveme maximálnu hĺbku niektorého z jeho vrcholov. Strom s jediným vrcholom má teda hĺbku 0; pre ostatné stromy je ich výška daná ako 1 plus maximum z výšok ľavého a pravého podstromu.

Nasledujúca funkcia počíta výšku stromu (kvôli elegancii zápisu pritom pracuje s rozšírením definície výšky stromu na prázdne stromy, za ktorých výšku sa považuje číslo -1).

/* Spocita vysku podstromu s korenom *root. Pre root == NULL vrati -1. */
int height(node *root) {
    if (root == NULL) {
        return -1;
    }
    int hLeft = height(root->left);    // rekurzivne spocita vysku laveho podstromu
    int hRight = height(root->right);  // rekurzivne spocita vysku praveho podstromu
    if (hLeft >= hRight) {             // vrati max(hLeft, hRight) + 1
        return hLeft + 1;
    } else {
        return hRight + 1;
    }
}

Pre výšku h stromu s n uzlami pritom platia nasledujúce vzťahy:

• Určite 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 \leq n-1} . Tento prípad nastáva, ak sú všetky uzly „navešané jeden pod druhý”.
• 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 \sum_{j=0}^h 2^j = 2^{h+1}-1} uzlov (ako možno ľahko dokázať indukciou vzhľadom na h).
• Z toho 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 \geq \log_2(n+1)-1} .
• Dostávame teda 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 \leq h \leq n-1} .
• Napríklad strom s milión vrcholmi má teda hĺbku medzi 19 a 999999.

Prehľadávanie stromov a vypisovanie ich uzlov

Často je potrebné prejsť celý strom a spracovať (napríklad vypísať) hodnoty vo všetkých uzloch. Toto prehľadávanie možno, podobne ako pri aritmetických stromoch, realizovať v troch základných poradiach: preorder, inorder a postorder.

/* Vypise podstrom s korenom *root v poradi preorder */
void printPreorder(node *root) {
    if (root == NULL) {
        return;
    }
    printDataType(root->data);
    printPreorder(root->left);
    printPreorder(root->right);
}

/* Vypise podstrom s korenom *root v poradi inorder */
void printInorder(node *root) {
    if (root == NULL) {
        return;
    }
    printInorder(root->left);
    printDataType(root->data);
    printInorder(root->right);
}

/* Vypise podstrom s korenom *root v poradi postorder */
void printPostorder(node *root) {
    if (root == NULL) {
        return;
    }
    printPostorder(root->left);
    printPostorder(root->right);
    printDataType(root->data);
}

Príklad: úplné binárne stromy

Binárny strom výšky h s maximálnym počtom vrcholov 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. Nasledujúca funkcia createCompleteTree vytvorí takýto strom a vráti smerník na jeho koreň. Jeho uzlom pritom priradí po dvoch rôzne hodnoty typu int (predpokladáme teda, že dataType je int) podľa globálnej premennej count.

// ...

int count;

/* Vytvori uplny binarny strom vysky height s datami uzlov count, count + 1, ... */ 
node *createCompleteTree(int height) {    
    if (height == -1) {
        return NULL;
    }
    node *v = createNode(count++, NULL, NULL);
    v->left = createCompleteTree(height - 1);
    v->right = createCompleteTree(height - 1);
    return v;
}

int main(void) {
    count = 1;
    node *root = createCompleteTree(3);
                     
    printf("Vyska: %d\n", height(root));                 
    printf("Inorder: ");
    printInorder(root);
    printf("\n");
    printf("Preorder: ");
    printPreorder(root);
    printf("\n");
    printf("Postorder: ");
    printPostorder(root);
    printf("\n");
                     
    destroyTree(root);                 
    return 0;
}

Cvičenie: popíšte poradie, v ktorom sa v uvedenom programe jednotlivým uzlom priraďujú ich hodnoty.

Prednáška 21

Oznamy

• V stredu 11. decembra bude o 18:10 v posluchárni A tretia písomka.

Binárne vyhľadávacie stromy

Budeme sa teraz zaoberať špeciálnym prípadom binárnych stromov, ktorým sú binárne vyhľadávacie stromy. Tie budú ďalšou z radu dátových štruktúr, ktoré možno použiť pri implementácii dynamickej množiny ako abstraktného dátového typu.

Príklad binárneho vyhľadávacieho stromu.

Binárny vyhľadávací strom je binárny strom, ktorého uzly majú priradené kľúče z nejakej úplne usporiadanej množiny (my budeme pre jednoduchosť uvažovať iba prípad, keď sú kľúčmi celé čísla). Pre každý uzol v s kľúčom key pritom platí:

• Každý vrchol v ľavom podstrome uzla v má hodnotu kľúča menšiu (alebo rovnakú) ako key.
• Každý vrchol v pravom podstrome uzla v má hodnotu kľúča väčšiu (alebo rovnakú) ako key.

Ak teda vypíšeme kľúče jednotlivých uzlov binárneho vyhľadávacieho stromu v poradí inorder, dostaneme ich postupnosť utriedenú vzostupne.

Typicky sa budeme zaujímať o prípad, keď sú kľúče jednotlivých uzlov po dvoch rôzne (nemusí to však byť vždy tak). Pre danú (multi)množinu kľúčov typicky existuje veľa rôznych binárnych vyhľadávacích stromov.

Cvičenie: nájdite všetky binárne vyhľadávacie stromy pozostávajúce z troch uzlov s kľúčmi 1, 2, 3.

Definícia štruktúr pre binárny vyhľadávací strom a jeho uzol

Štruktúra node pre uzol binárneho vyhľadávacieho stromu bude veľmi podobná, ako pri všeobecných binárnych stromoch. Spomedzi dát uložených v uzle je najpodstatnejší kľúč key, pričom na tejto prednáške sa obmedzíme na celočíselné kľúče. Okrem kľúča môžu byť v uzle uložené aj ďalšie, tzv. satelitné, dáta – tie však pre jednoduchosť uvažovať nebudeme. Okrem smerníkov na ľavého a pravého syna bude navyše každý uzol obsahovať aj smerník na svojho otca (v prípade koreňa bude mať hodnotu NULL).

Na binárny vyhľadávací strom kladieme globálne podmienky ohľadom kľúčov jeho uzlov. V prípade „ručnej” manipulácie s jeho uzlami by mohlo dôjsť k narušeniu platnosti týchto podmienok (napríklad by sme mohli niektorému ľavému synovi priradiť väčší kľúč, než má jeho otec). Aby sme predišli takýmto problémom, definujeme okrem štruktúry node pre jednotlivé uzly aj štruktúru binarySearchTree realizujúcu „obal” pre celý binárny vyhľadávací strom. Následne definujeme niekoľko funkcií na prácu s binárnymi vyhľadávacími stromami prostredníctvom štruktúry binarySearchTree. Používateľ, ktorý bude na prácu s binárnymi vyhľadávacími stromami používať výhradne tieto funkcie, by nikdy nemal mať možnosť porušiť podmienky platné v binárnych vyhľadávacích stromoch.

/* Uzol binarneho vyhladavacieho stromu. */
struct node {
    int key;       // kluc, podla ktoreho budeme porovnavat prvky (namiesto int aj ina uplne usporiadana mnozina) 
    
    /* Sem mozu prist lubovolne dalsie satelitne data ulozene v danom uzle. */
    
    node *parent;  // smernik na otca (NULL, ak neexistuje)
    node *left;    // smernik na laveho syna (NULL, ak tento syn neexistuje)
    node *right;   // smernik na praveho syna (NULL, ak tento syn neexistuje)
};


// ...


/* Samotna struktura binarneho vyhladavacieho stromu (obal pre pouzivatela). */
struct binarySearchTree {
    node *root;
};

Inicializácia binárneho vyhľadávacieho stromu

Nasledujúca funkcia realizuje inicializáciu binárneho vyhľadávacieho stromu t.

/* Inicializuje prazdny binarny vyhladavaci strom. */
void bstInit(binarySearchTree &t) {
    t.root = NULL;
}

Likvidácia binárneho vyhľadávacieho stromu

Likvidáciu podstromu zakoreneného v danom uzle *root realizujeme funkciou destroy, obdobne ako pri všeobecných binárnych stromoch. Používateľovi navyše dáme k dispozícii aj „baliacu” funkciu bstDestroy, ktorá zlikviduje binárny vyhľadávací strom t tak, že zavolá funkciu destroy na jeho koreň.

/* Uvolni pamat pre podstrom s korenom *root. */
void destroy(node *root) {
    if (root != NULL) {
        destroy(root->left);
        destroy(root->right);
        delete root;
    }
}


// ...


/* Zlikviduje strom t (uvolni pamat). */
void bstDestroy(binarySearchTree &t) {
    destroy(t.root);
}

Hľadanie v binárnom vyhľadávacom strome

Nasledujúca funkcia findNode sa pokúsi v podstrome zakorenenom v uzle *root vyhľadať uzol, ktorého kľúč je rovný key. Ak existuje aspoň jeden taký uzol, vráti smerník na niektorý z nich (to je užitočné najmä v prípade, keď sú kľúče po dvoch rôzne). V opačnom prípade vráti NULL.

Pri hľadaní uzla s hodnotou key bude funkcia findNode využívať definujúcu vlastnosť binárnych vyhľadávacích stromov: ak je hľadaná hodnota kľúča key menšia, než kľúč koreňa podstromu *root, pokračuje v hľadaní v jeho ľavom podstrome; ak je naopak väčšia, pokračuje v hľadaní v jeho pravom podstrome. Ak je kľúč koreňa *root rovný key, ide o hľadaný uzol a smerník naň tak možno ihneď vrátiť na výstupe.

Používateľovi pritom opäť poskytneme aj „baliacu” funkciu bstFind, ktorá zavolá funkciu findNode pre koreň daného binárneho vyhľadávacieho stromu t a pomocou nej zistí, či tento strom obsahuje uzol s kľúčom key.

/* Ak v strome s korenom *root existuje uzol s klucom key, vrati ho na vystupe. Inak vrati NULL. */
node *findNode(node *root, int key) {
    if (root == NULL || root->key == key) {
        return root;
    } else if (key < root->key) {
        return findNode(root->left, key);
    } else {
        return findNode(root->right, key);
    }
}


// ...


/* Zisti, ci strom t obsahuje uzol s klucom key. */
bool bstFind(binarySearchTree &t, int key) {
    return findNode(t.root, key) != NULL;
}

Čas výpočtu je v najhoršom prípade úmerný výške stromu. Poznamenajme ešte, že funkciu findNode je možné realizovať aj nerekurzívne, napríklad takto:

node *findNode(node *root, int key) {
    node *v = root;
    while (v != NULL && v->key != key) {
        if (key < v->key) {
            v = v->left;
        } else {
            v = v->right;
        }
    }
    return v;
}

Vkladanie do binárneho vyhľadávacieho stromu

Nasledujúca funkcia insertNode vloží uzol *v na správne miesto podstromu zakoreneného v *root ako jeho list. Postupuje pritom rekurzívne: ak zistí, že uzol *v má kľúč menší, než *root, pokúsi sa ho vložiť do ľavého podstromu uzla *root; v opačnom prípade sa ho pokúsi vložiť do pravého podstromu.

Používateľovi následne poskytneme „baliacu” funkciu bstInsert, ktorá vytvorí uzol s daným kľúčom key a pomocou funkcie insertNode ho vloží do binárneho vyhľadávacieho stromu t.

/* Vlozi uzol *v na spravne miesto podstromu zakoreneneho v *root */
void insertNode(node *root, node *v) {
    assert(root != NULL && v != NULL);
    if (v->key < root->key) {
        if (root->left == NULL) {
            root->left = v;
            v->parent = root;
        } else {
            insertNode(root->left, v);
        }
    } else {
        if (root->right == NULL) {
            root->right = v;
            v->parent = root;
        } else {
            insertNode(root->right, v);
        }
    }
}


// ...


/* Vlozi do stromu t novy uzol s klucom key. */
void bstInsert(binarySearchTree &t, int key) {
    node *v = new node;
    v->key = key;
    v->left = NULL;
    v->right = NULL;
    v->parent = NULL;
    if (t.root == NULL) {
        t.root = v;
    } else {
        insertNode(t.root, v);
    }
}

Čas vkladania je tiež v najhoršom prípade úmerný hĺbke stromu.

Cvičenie č. 1: napíšte nerekurzívny variant funkcie insertNode.

Cvičenie č. 2: napíšte funkciu treeSort, ktorá z poľa celých čísel a pomocou volaní funkcie bstInsert vytvorí binárny vyhľadávací strom a následne pomocou prehľadávania tohto stromu v poradí inorder pole a utriedi.

Minimálny uzol

Nasledujúca funkcia minNode nájde v podstrome zakorenenom v *root uzol s minimálnym kľúčom. Je pritom založená na skutočnosti, že všetky uzly tohto podstromu s kľúčom menším ako root->key sa musia nachádzať v ľavom podstrome uzla *root.

„Obalom” pre používateľa bude funkcia bstMin, ktorá pomocou funkcie minNode nájde minimálny kľúč v danom binárnom vyhľadávacom strome t.

/* Vrati (niektory) uzol s minimalnou hodnotou key v podstrome s korenom *root. */
node *minNode(node *root) {
    assert(root != NULL);
    if (root->left != NULL) {
        return minNode(root->left);
    } else {
        return root;
    }
}


// ...


/* Vrati minimalny kluc uzla v strome t. */
int bstMin(binarySearchTree &t) {
    assert(t.root != NULL);
    return minNode(t.root)->key; 
}

Cvičenie: napíšte nerekurzívny variant funkcie minNode.

Následník uzla

Funkcia successorNode nájde pre daný uzol *v jeho následníka (angl. successor) v binárnom vyhľadávacom strome – čiže uzol, ktorý vo vzostupnom poradí podľa kľúčov nasleduje bezprostredne za uzlom *v. Je pritom založená na nasledujúcich pozorovaniach:

• Ak má uzol *v pravého syna, následník uzla *v musí byť v jeho pravom podstrome – konkrétne pôjde o minimálny uzol z tohto podstromu.
• V opačnom prípade môže byť následníkom uzla *v jeho otec (ak *v je jeho ľavý syn). Ak je *v pravým synom svojho otca, môže to byť aj jeho starý otec (ak je otec uzla *v ľavým synom tohto starého otca), atď. Vo všeobecnosti teda ide o najbližšieho predka uzla *v takého, že *v patrí do jeho ľavého podstromu.

/* Vrati uzol, ktory vo vzostupnom poradi uzlov podla klucov nasleduje za *v. Ak taky uzol neexistuje, vrati NULL. */
node *successorNode(node *v) {
    assert(v != NULL);
    if (v->right != NULL) {
        return minNode(v->right);
    }
    while (v->parent != NULL && v == v->parent->right) {
        v = v->parent;
    }
    return v->parent;
}

Mazanie z binárneho vyhľadávacieho stromu

Nasledujúca funkcia bstRemove zmaže z binárneho vyhľadávacieho stromu t práve jeden uzol s kľúčom key (ak sa taký uzol v strome vyskytuje). Pracuje tak, že najprv pomocou funkcie findNode nájde uzol *v s kľúčom key. V prípade úspechu zistí počet synov uzla *v. Ak totiž *v nemá žiadneho syna alebo má len jedného syna, možno ho zo stromu t zmazať jednoducho tak, že sa prípadný syn uzla *v stane synom otca uzla *v. V prípade, že má *v dvoch synov je však zrejmé, že jeho následník sa musí nachádzať v jeho neprázdnom pravom podstrome. Tento následník *rm navyše nemôže mať ľavého syna. Odstránenie kľúča key je teda možné realizovať tak, že sa kľúč uzla *rm presunie do uzla *v a následne sa odstráni uzol *rm tak, ako je popísané vyššie.

/* Zmaze zo stromu t prave jeden uzol s klucom key (ak tam taky je). */
void bstRemove(binarySearchTree &t, int key) {
    node *v = findNode(t.root, key);                   // Najde uzol v s hodnotou, ktoru treba vymazat.
    if (v == NULL) {
        return;
    }
    
    node *rm;                                          // Najde uzol *rm stromu t, ktory sa napokon realne zmaze.   
    if (v->left == NULL || v->right == NULL) {         
        rm = v;
    } else  {
        rm = successorNode(v);
    }
   
    if (rm != v) {                                     // Ak rm != v, presunie kluc uzla *rm do uzla *v. 
        v->key = rm->key;
    }
    
    node *child;                                       // Zmaze uzol *rm a uvolni pamat alokovanu pre tento uzol.
    if (rm->left != NULL) {
        child = rm->left;
    } else {
        child = rm->right;
    }                   
    if (child != NULL) {
        child->parent = rm->parent;
    }
    if (rm->parent == NULL) {
        t.root = child;
    } else if (rm == rm->parent->left) {
        rm->parent->left = child;    
    } else if (rm == rm->parent->right) {
        rm->parent->right = child;
    }
    delete rm;
}

Zložitosť jednotlivých operácií

• Časová zložitosť operácií bstFind(t), bstInsert(t) aj bstRemove(t) je úmerná hodnote height(t), čo je výška stromu t.
• Minule sme ukázali, že pre výšku h stromu s n vrcholmi 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 \log_2(n+1)-1 \leq h \leq n-1} .
• Zložitosť uvedených operácií je teda v najhoršom prípade lineárna od počtu uzlov stromu (tento prípad nastane, ak prvky vkladáme od najmenšieho po najväčší alebo naopak).
• Dá sa však ukázať, že v priemernom prípade je ich zložitosť rádovo logaritmická od počtu uzlov.
• Na predmete Algoritmy a dátové štruktúry (druhý ročník) sa tieto tvrdenia dokazujú poriadne a preberajú sa tam aj varianty vyhľadávacích stromov, pre ktoré je zložitosť uvedených operácií logaritmická aj v najhoršom prípade.

Príklad programu pracujúceho s binárnymi vyhľadávacími stromami

Nasledujúci program realizuje základné operácie s binárnymi vyhľadávacími stromami podľa príkazov zadávaných používateľom na konzolu.

#include <cstdio>
#include <cstring>
#include <cassert>


// ...


int main(void) {
    binarySearchTree t;
    bstInit(t);
    char command[20];
    int key;
    while (true) {
        scanf("%19s", command);
        if (strcmp(command, "insert") == 0) {
            scanf("%d", &key);
            bstInsert(t, key);
        }
        if (strcmp(command, "remove") == 0) {
            scanf("%d", &key);
            bstRemove(t, key);
        }
        if (strcmp(command, "find") == 0) {
            scanf("%d", &key);
            bool b = bstFind(t, key);
            if (b) {
                printf("YES\n");
            } else {
                printf("NO\n");
            }
        }
        if (strcmp(command, "min") == 0) {
            printf("%d\n", bstMin(t));
        }
        if (strcmp(command, "exit") == 0) {
            break;
        }
    }
    bstDestroy(t);                     
    return 0;
}

Prednáška 22

Oznamy

• Ďalšia prednáška v stredu 11. decembra bude venovaná informáciám o skúškach.
• V stredu 11. decembra bude o 18:10 v posluchárni A tretia písomka.
• Do piatku 13. decembra, 22:00 treba odovzdať štvrtú domácu úlohu.
• Termín druhej a tretej opravnej písomky bude dohodnutý na prednáške v pondelok 16. decembra.

Lexikografické stromy

Lexikografický strom reprezentujúci množinu reťazcov a, aj, ale, aleba, alebo, cez, na, nad.

Lexikografické stromy (niekde tiež prefixové stromy; angl. trie zo slova retrieval) sú dátová štruktúra na uchovávanie množiny reťazcov. Ide o stromy, ktoré nemusia byť binárne:

• Každý uzol lexikografického stromu má najviac toľko synov, koľko je písmen v uvažovanej abecede. Každý zo synov zodpovedá práve jednému písmenu abecedy a každému písmenu abecedy zodpovedá najviac jeden syn daného uzla. Graficky možno písmená zodpovedajúce jednotlivým synom znázorniť ohodnotením hrán spájajúcich dané uzly.
• Koreň lexikografického stromu zodpovedá prázdnemu reťazcu.
• Uzol v hĺbke k zodpovedá reťazcu dĺžky k, ktorý dostaneme prečítaním písmen na ceste z koreňa do daného uzla.
• Každý uzol lexikografického stromu obsahuje informáciu (true alebo false) o tom, či k nemu prislúchajúci reťazec patrí do množiny reprezentovanej týmto lexikografickým stromom alebo nie.
• V korektnom lexikografickom strome všetky listy zodpovedajú reťazcom z reprezentovanej množiny; niektoré reťazce reprezentovanej množiny však môžu zodpovedať aj vnútorným vrcholom stromu. Každý uzol lexikografického stromu tak zodpovedá nejakému prefixu slova z ním reprezentovanej množiny – odtiaľ alternatívne pomenovanie prefixový strom.

Štruktúra node pre uzol lexikografického stromu tak obsahuje booleovskú premennú isWord, v ktorej je uložená informácia o tom, či reťazec prislúchajúci k danému uzlu patrí alebo nepatrí do reprezentovanej množiny a pole children smerníkov na jednotlivých synov daného uzla. Veľkosť alphSize tohto poľa je rovná veľkosti uvažovanej abecedy – pre písmená malej anglickej abecedy je táto hodnota rovná 'z' - 'a' + 1.

Pri rôznych praktických aplikáciách môže štruktúra node obsahovať aj rozličné ďalšie informácie – pre každé slovo z reprezentovanej množiny si napríklad môžeme pamätať jeho frekvenciu výskytu, preklad do nejakého iného jazyka a podobne.

const int alphSize = 'z' - 'a' + 1;

struct node {
    node *children[alphSize]; // pole smernikov na deti
    bool isWord;              // udava, ci uzol prislucha k slovu z reprezentovanej mnoziny
    // dalsie data (napriklad preklad slova, pocet vyskytov slova v texte, ...)
};

Samotný lexikografický strom je potom daný iba smerníkom na svoj koreň:

struct trie {
    node *root;      
};

Inicializácia lexikografického stromu

Nasledujúca funkcia inicializuje prázdny lexikografický strom t:

void trieInit(trie &t) {
    t.root = NULL; 
}

Likvidácia lexikografického stromu

Uvoľnenie pamäte alokovanej pre podstrom zakorenený v uzle root realizujeme obdobne ako pri binárnych vyhľadávacích stromoch. Jediný rozdiel spočíva v potenciálne väčšom počte synov uzla root.

void destroySubtree(node *root) {
    if (root != NULL) {
        for (int i = 0; i <= alphSize - 1; i++) {
            destroySubtree(root->children[i]);
        }
        delete root;
    }
}

Nasledujúca funkcia potom zlikviduje celý lexikografický strom t:

void trieDestroy(trie &t) {
    destroySubtree(t.root);
}

Vkladanie do lexikografického stromu

Pri vkladaní reťazca do množiny realizovanej lexikografickým stromom často vznikne potreba vytvárať nové uzly tohto stromu. Túto podúlohu realizuje funkcia createNode, ktorá vytvorí nový uzol s hodnotou isWord danou jej argumentom a so všetkými smerníkmi na synov rovnými NULL.

node *createNode(bool isWord) {
    node *v = new node;
    for (int i = 0; i <= alphSize - 1; i++) {
        v->children[i] = NULL;
    }
    v->isWord = isWord;
    return v;
}

Vloženie reťazca word do lexikografického stromu t potom realizuje funkcia trieInsert, ktorá pracuje nasledovne:

• Začne v koreni stromu, odkiaľ postupuje nižšie smerom k listom.
• V každom uzle sa pozrie na ďalšie písmeno slova word. Ak danému uzlu chýba syn pre toto písmeno, vytvorí ho pomocou funkcie createNode. Následne sa presunie do tohto syna.
• Ak v nejakom uzle v príde na koniec slova word, nastaví hodnotu v->isWord na true.

void trieInsert(trie &t, const char *word) {
    if (t.root == NULL) {
        t.root = createNode(false);
    }
    node *v = t.root;
    for (int i = 0; word[i] != 0; i++) {
        int c = word[i] - 'a';
        if (v->children[c] == NULL) {
            v->children[c] = createNode(false);
        }
        v = v->children[c];
    }
    v->isWord = true;
}

Hľadanie v lexikografickom strome

Funkcia treeFind pre daný lexikografický strom t a reťazec word zistí, či slovo word patrí do množiny reprezentovanej stromom t. Opäť pritom postupuje po písmenách reťazca word. Kým nedôjde na koniec slova, snaží sa ísť po hranách, ktoré zodpovedajú jednotlivým písmenám. V prípade, že v niektorom bode narazí na NULL, slovo word sa v strome nenachádza. V opačnom prípade toto slovo dočíta v nejakom uzle v. V takom prípade slovo word patrí do reprezentovanej množiny práve vtedy, keď v->isWord má hodnotu true.

bool trieFind(trie &t, const char *word) {
    node *v = t.root;
    if (v == NULL) {
        return false;
    }
    for (int i = 0; word[i] != 0; i++) {
        v = v->children[word[i] - 'a'];
        if (v == NULL) {
            return false;
        }
    }
    return v->isWord;
}

Vymazávanie z lexikografického stromu

Vymazávanie slov z množiny reprezentovanej lexikografickým stromom budeme realizovať prostredníctvom pomocnej rekurzívnej funkcie removeFromSubtree, ktorá z podstromu zakorenenom v uzle *root vymaže sufix reťazca word začínajúci na pozícii index. Táto funkcia vráti na výstupe booleovskú hodnotu podľa toho, či sa pri tomto vymazaní sufixu z daného podstromu vymazal jeho koreň *root (táto situácia nenastane vždy: napríklad pri mazaní slova a z podstromu reprezentujúceho množinu slov {a,ab} uzol prislúchajúci k reťazcu a v strome ostáva; zmení sa len jeho hodnota isWord).

Ak sa slovo word v reprezentovanej množine nenachádza, funkcia removeFromSubtree vyhlási chybu pomocou funkcie assert.

Funkcia removeFromSubtree pracuje nasledovne:

• Ak je sufix reťazca word začínajúci na indexe index prázdny, nastaví hodnotu root->isWord na false.
• V opačnom prípade funkcia removeFromSubtree zavolá rekurzívne samú seba pre syna zodpovedajúceho písmenu na pozícii index reťazca word. Ak toto volanie daného syna zmaže, prestaví smerník na tohto syna na NULL.
• V prípade, že po vykonaní jednej z predchádzajúcich dvoch operácií nemá uzol root žiadneho syna a súčasne má root->isWord hodnotu false, uvoľní pamäť alokovanú pre uzol root a informáciu o jeho zmazaní vráti na výstupe.

bool removeFromSubtree(node *root, const char *word, int index) {
    assert(root != NULL);
    if (word[index] == 0) {
        assert(root->isWord);
        root->isWord = false;
    } else {
        int c = word[index] - 'a';
        bool deleted = removeFromSubtree(root->children[c], word, index + 1);
        if (deleted) {          
            root->children[c] = NULL;
        }
    }
    int numChildren = 0;                        
    for (int i = 0; i <= alphSize - 1; i++) {
        if (root->children[i] != NULL) {
            numChildren++;
        }
    }
    if (numChildren == 0 && !root->isWord) {
        delete root;
        return true;
    }
    return false;
}

Samotné odstránenie reťazca word z množiny reprezentovanej stromom t potom realizuje nasledujúca funkcia trieRemove. Tá len zavolá funkciu removeFromSubtree pre koreň stromu t a v prípade, že volanie tejto funkcie koreň zo stromu odstráni, nastaví t.root na NULL.

void trieRemove(trie &t, const char *word) {
    bool rootRemoved = removeFromSubtree(t.root, word, 0);
    if (rootRemoved) {
        t.root = NULL;
    }
}

Výška lexikografického stromu

Nasledujúca funkcia vypočíta výšku podstromu zakoreneného v uzle *root (definovaná je rovnako ako pre binárne stromy):

int subtreeHeight(node *root) {
    if (root == NULL) {
        return -1;
    }
    int maxHeight = -1;
    for (int i = 0; i <= alphSize - 1; i++) {
        int height = subtreeHeight(root->children[i]);
        if (height > maxHeight) {
            maxHeight = height;
        }
    }
    return maxHeight + 1;
}

Výšku samotného lexikografického stromu t potom spočíta nasledujúca funkcia:

int trieHeight(trie &t) {
    return subtreeHeight(t.root);
}

Vypisovanie slov reprezentovaných lexikografickým stromom

Nasledujúca funkcia printSubtree prehľadáva podstrom zakorenený v uzle *root a v reťazci s postupne generuje všetky slová z reprezentovanej množiny, ktoré zároveň vypisuje na konzolu.

void printSubtree(node *root, char *s, int index) {
    if (root == NULL) {
        return;
    }
    if (root->isWord) {
        s[index] = 0;
        printf("%s\n", s);
    }
    for (int i = 0; i <= alphSize - 1; i++) {
        s[index] = 'a' + i;
        printSubtree(root->children[i], s, index + 1);
    }
}

Funkcia triePrint vypisujúca všetky slová v množine reprezentovanej lexikografickým stromom t najprv spočíta výšku stromu t, ktorá je rovná dĺžke najdlšieho reťazca tejto množiny. Následne dynamicky alokuje reťazec dostatočnej dĺžky na uchovanie každého slova množiny a zavolá funkciu printSubtree pre koreň stromu t.

void triePrint(trie &t) {
    int height = trieHeight(t);
    if (height >= 0) { 
        char *s = new char[height + 1];
        printSubtree(t.root, s, 0);
        delete[] s;
    }
}

Program pracujúci s lexikografickými stromami

Nasledujúci program načítava z konzoly príkazy zodpovedajúce operáciám na lexikografickom strome a za každým načítaným príkazom túto operáciu vykonáva.

#include <cstdio>
#include <cassert>
#include <cstring>


// ...


int main(void) {
    trie t;
    trieInit(t);
    char command[20];
    char arg[20];
    while (true) {
        scanf("%19s", command);
        if (strcmp(command, "insert") == 0) {
            scanf("%19s", arg);
            trieInsert(t, arg);
        }
        if (strcmp(command, "find") == 0) {
            scanf("%19s", arg);
            bool b = trieFind(t, arg);
            if (b) {
                printf("YES\n");
            } else {
                printf("NO\n");
            }
        }
        if (strcmp(command, "remove") == 0) {
            scanf("%19s", arg);
            trieRemove(t, arg);
        }
        if (strcmp(command, "height") == 0) {
            printf("%d\n", trieHeight(t));
        }
        if (strcmp(command, "print") == 0) {
            triePrint(t);
        }
        if (strcmp(command, "exit") == 0) {
            break;
        }
    }
    trieDestroy(t);
    return 0;
}

Prednáška 23

Oznamy

Koniec semestra:

• Dnešná prednáška: informácia o skúškach, detaily skúšky z programovania, opakovanie, vaše otázky
• Pondelok prednáška: nepreberané črty C resp. C++. Nebudeme skúšať, ale môžu sa zísť (môžete použiť aj na skúške). Dohadovanie termínu opravnej písomky 2 a 3 (doneste si termíny iných skúšok).
• Budúcu stredu prednáška nebude
• Cvičenia budúci týždeň: už dnes po prednáške sa na testovači objavia tréningové príklady na skúšku. Za niektoré budete môcť získať bonusový bod, ak ich vyriešite do 7.1. (ako tréning sa dajú riešiť aj neskôr). V utorok na cvičeniach pribudne ešte jeden tréningový príklad za 4 body. Ak prídete na cvičenia a budete usilovne pracovať na tomto príklade, získate jeden bonusový bod, aj keď ho nestihnete dokončiť.
  • Ak ste na cvičeniach používali vlastný počítač alebo webové prostredia, odporúčame vám vyskúšať si aspoň teraz prácu v linuxovom prostredí v učebni, aby ste vedeli, čo môžete použiť na skúške.
  • Dobrým nápadom je naučiť sa používať aj program #Valgrind, ktorý vám na skúške môže pomôcť nájsť chýbajúce odalokovanie alebo chybu, pre ktorú váš program padá
• Namiesto piatkových cvičení budúci týždeň bude predtermín skúšky

• Pred skúškou si skontrolujte body na testovači. Prípadné reklamácie pošlite na prog@.... Na/po skúške už reklamácie bodov z cvičení a domácich úloh nebudeme riešiť.
• Ak ste namiesto úloh robili rýchlostné programovanie, nezabudnite do 20.12. odovzdať zoznam príkladov vyriešených v C alebo C++ podľa pokynov na testovači.

Iné

• Do konca skúškového môžete vypĺňať študentskú anketu: https://anketa.uniba.sk/fmph/ Tešíme sa na konštruktívne návrhy, ktoré nám pomôžu zlepšiť predmet do budúcnosti.
• Ak by ste cez skúškové obdobie mali záujem o konzultácie pred opravným testom alebo pred skúškou, dajte nám vedieť.

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}; 
int B[4];               
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 matice
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;

Abstraktné dátové typy

Abstraktný dátový typ dynamické pole (rastúce pole)

• operácie init, add, get, set, length

Abstraktný dátový typ množina (set)

• operácie init, find, insert, remove
• implementácie pomocou
  • neutriedeného poľa
  • utriedeného poľa
  • spájaných zoznamov
  • binárnych vyhľadávacích stromov
  • hešovacej tabuľky
  • lexikografického stromu (ak kľúč je reťazec)

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

Dátové štruktúry

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

Hešovanie

• hešovacia tabuľka veľkosti m
• kľúč k premietneme nejakou funkciou na index v poli (0,...,m-1}
• každé políčko hešovacej tabuľky spájaný zoznam prvkov, ktoré sa tam zahešovali
• v ideálnom prípade sa prvky rozhodia pomerne rovnomerne, zoznamy krátke, rýchle hľadanie, vkladenie, mazanie
• v najhoršom prípade všetky prvky v jednom zozname, pomalé hľadanie a mazanie

int hash(int k, int m){ // veľmi jednoduchá hešovacia funkcia, v praxi väčšinou zložitejšie
    return abs(k) % m;
}
struct node {
    int item;
    node* next;
};

struct set {
    node** data;
    int m;
};

Algoritmy

Rekurzia

• Rekurzívne 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

Matematické úlohy

• Euklidov algoritmus, Eratostenovo sito
• Práca s aritmetickými výrazmi: vyhodnocovanie postfixovej formy, prevod z infixovej do postfixovej, reprezentácia vo forme stromu

Prednáška 24

Dnešná prednáška bude venovaná (pomerne plytkému) prehľadu rôznych čŕt jazykov C a C++, ktoré sa počas semestra nepreberali. Tento prehľad by mal poslúžiť ako pomôcka pri štúdiu existujúcich programov, resp. ako inšpirácia pre ďalšie samoštúdium.

Znalosť materiálu z tejto prednášky nebude vyžadovaná na skúške. Rovnako nie je odporúčané na skúške tento materiál využívať bez dôkladného samostatného oboznámenia sa s ním.

Táto prednáška nepokrýva objektovo-orientované programovanie v jazyku C++. Objektovo-orientované programovanie (v jazyku Java) bude hlavnou náplňou druhého semestra programovania.

Rozdiely medzi jazykmi C a C++

Jazyk C vznikol okolo roku 1972 na podporu vývoja operačného systému Unix; jazyk C++ okolo roku 1985. Programy v jazyku C sú väčšinou súčasne aj korektnými programami v jazyku C++ (ide ale o isté zjednodušenie). Obidva tieto jazyky existujú vo viacerých štandardoch, v ktorých sa postupne pridávali nové črty.

V priebehu semestra sme programovali v jazyku C++. Veľká časť konštrukcií, ktoré sme v programoch využívali, však pochádza už z jazyka C. Výnimkami sú však napríklad nasledujúce črty jazyka C++, ktoré v jazyku C nie sú k dispozícii:

• V jazyku C nie je možné predávanie parametrov funkcií referenciou. Namiesto toho je potrebné používať smerníky.
• V jazyku C nefungujú operátory new a delete. Namiesto nich treba použiť funkcie popísané nižšie.
• Na používanie typu bool a konštánt true a false je potrebná knižnica stdbool (t. j. #include <stdbool.h>). Zabudovaný booleovský typ má názov _Bool a nadobúda hodnoty 0 a 1.
• Štandardnými knižnicami jazyka C sú spomedzi štandardných knižníc jazyka C++ v zásade tie začínajúce písmenom c, napríklad cstdio. Namiesto #include <cstdio> potom v C píšeme #include <stdio.h>.
  • V jazyku C špeciálne nie je možné používať knižnicu iostream a v nej definované štandardné vstupno-výstupné prúdy cin a cout.
• V starších verziách jazyka C nefungujú mnohé konštrukcie jazyka C++, ktoré sme bežne používali – napríklad komentáre vo forme //, deklarácie premenných inde ako na začiatku funkcie, atď.

Nepreberané črty jazyka C (použiteľné aj v C++)

Enumerované typy

Enumerované typy pozostávajú z vymenovania niekoľkých hodnôt, ktoré sa stanú celočíselnými konštantami. To je občas užitočné na sprehľadnenie zdrojového kódu.

Príklad:

#include <iostream>
using namespace std;

int main(void) {
    enum farba {biela, modra, cervena, zelena, cierna};  // definicia enumerovaneho typu farba
    farba f = biela;                                     // definicia premennej typu farba     
    f = zelena;                                          // priradenie do premennej typu farba  
    cout << f << endl;                                   // vypise 3
    return 0;
}

Zložený typ (union)

Zložený typ umožňuje na jednom mieste pamäte uchovávať hodnotu, ktorá môže byť viacerých dátových typov (narozdiel od štruktúr však vždy ide o práve jednu hodnotu). Definuje sa podobne ako štruktúra, avšak s použitím kľúčového slova union namiesto struct.

Príklad:

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

union zlozenyTyp {
    int n;
    char s[100];
};

int main(void) {
    zlozenyTyp z;
    z.n = 10;
    cout << z.n << endl;  // vypise 10
    strcpy(z.s, "abcd");
    cout << z.s << endl;  // vypise abcd
    cout << z.n << endl;  // vypise nejaky nezmysel
    return 0;
}

Napríklad pri aritmetických stromoch by použitie zloženého typu umožnilo ušetriť trochu pamäte tým, že by sme si v každom uzle pamätali buď jeho hodnotu, alebo operátor a smerníky na synov.

Operátory

Okrem operátorov, ktoré sme používali, existuje niekoľko ďalších, ako napríklad nasledujúce:

• 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 ? s použitím (podmienka)?(hodnota pre true):(hodnota pre false), napríklad cout << x << " je " << ((x%2==0) ? "parne" : "neparne") << endl;

Cyklus do-while

Cyklus do-while je obdobou cyklu while s vyhodnocovaním podmienky na konci iterácie. 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

Konštantu možno zadefinovať napríklad aj takto:

#define MAXN 100

Narozdiel od konštanty s definíciou

const int maxN = 100;

sa tu konštantná premenná MAXN reálne nevytvára (nevyhradzuje sa pre ňu pamäťové miesto); všetky výskyty MAXN sú preprocesorom kompilátora nahradené „ešte v zdrojovom kóde” konštantou 100.

Okrem konštánt možno 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 vykona substituciu za MIN, ktorou dostane: */
cout << ((a*a) < (b+5) ? (a*a) : (b+5));

• Bez dostatočného množstva zátvoriek by pri použití makra MIN mohlo dôjsť k „interakcii s okolím”.
• Vo všeobecnosti je odporúčané vyvarovať sa použitia makier.

Delenie programu na súbory

Väčšie programy je zvyčajne žiadúce rozdeliť na viacero zdrojových súborov. Často sa tiež môže zísť vytvorenie vlastnej knižnice.

Kompilátory, ako napríklad g++, spravidla umožňujú skompilovať viacero zdrojových súborov naraz. Pri volaní g++ z príkazového riadku môžeme písať napríklad

g++ -o program subor1.cpp subor2.cpp subor3.cpp

Takéto volanie ale môže byť úspešné len za dvoch podmienok:

• Funkciu main musí obsahovať práve jeden z kompilovaných zdrojových súborov.
• Ak sa v niektorom súbore suborA.cpp využíva funkcia f z iného súboru suborB.cpp, musí byť funkcia f v súbore suborA.cpp zadeklarovaná (t. j. uvedie sa hlavička funkcie f nasledovaná bodkočiarkou, bez samotného tela – čiže definície – funkcie f).

V súbore lib.cpp môžeme mať napríklad definície dvoch funkcií f a g:

/* Subor lib.cpp */

int f(int n) {
    return n + 1;
}

int g(int n) {
    return n*2;
}

Môžeme teraz do súboru prog.cpp napísať program, ktorý tieto funkcie deklaruje a následne využíva:

/* Subor prog.cpp */

#include <iostream>
using namespace std;

int f(int n);
int g(int n);

int main(void) {
    int n;
    cin >> n;
    cout << f(n) << " " << g(n) << endl;
    return 0;
}

Program potom možno skompilovať volaním

g++ -o prog prog.cpp lib.cpp

Manuálne deklarovanie všetkých funkcií môže byť obzvlášť pri veľkých knižniciach a programoch pozostávajúcich z veľkého množstva súborov ťažkopádne. Typickým riešením je preto presunutie všetkých deklarácií do špeciálneho hlavičkového súboru (angl. header file), v našom prípade napríklad lib.h. Direktíva #include "lib.h" potom prekopíruje do súboru, ktorý ju obsahuje, kompletný obsah súboru lib.h, čím sa vlastne deklarujú všetky funkcie z knižnice lib.cpp.

Pre náš príklad vyššie tak teraz máme 3 súbory. Súbor lib.cpp je rovnaký ako vyššie, súbor lib.h obsahuje

/* Subor lib.h */

int f(int n);
int g(int n);

a súbor prog.cpp obsahuje

/* Subor prog.cpp */

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

int main(void) {
    int n;
    cin >> n;
    cout << f(n) << " " << g(n) << endl;
    return 0;
}

Program skompilujeme rovnako ako vyššie:

g++ -o prog prog.cpp lib.cpp

Rozdiel medzi direktívami #include "lib.h" a #include <lib.h> spočíva v tom, že kým v prvom prípade sa hlavičkový súbor hľadá najprv v aktuálnom adresári, v druhom prípade sa prehľadávajú iba adresáre, ktoré sú na danom systéme predvolené (typicky ide o adresáre obsahujúce hlavičky štandardných knižníc).

Zopár užitočných funkcií

Alokácia pamäte

• V jazyku C nie sú definované operátory new a delete, resp. new[] a delete[].
• Pamäť sa alokuje funkciou malloc, ktorá alokuje kus pamäte s daným počtom bajtov.
  • V prípade neúspechu vráti NULL.
  • V prípade úspechu vráti smerník na void, ktorý je následne nutné pretypovať.
• Uvoľnenie pamäte realizuje funkcia free.
• Pri výpočte veľkosti potrebnej pamäte sa zvyčajne používa operátor sizeof.

#include <cstdlib>   // resp. #include <stdlib.h> v C

/* 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 dva smerníky typu void * (na dva prvky poľa).
  • Vráti záporné číslo, ak prvý prvok je menší, nulu, ak sú rovnaké a kladné číslo, ak je prvý 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);

• Existuje napríklad aj funkcia bsearch na binárne vyhľadávanie v utriedenom poli.

Konštantné argumenty

• V príklade vyššie máme funkciu s hlavičkou int compare(const void *a, const void *b).
• Argumentom typu const void *a programátor „sľubuje”, že nebude meniť obsah pamäte, na ktorú ukazuje smerník a.
• Napríklad pre funkciu void f(const int *a) {*a = 5;} teda kompilátor vyhlási 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 * a nie void *.
• Za dobrú prax sa považuje používanie const na všetky parametre typu smerník alebo referencia, ktoré funkcia nepotrebuje meniť.

Nepreberané črty jazyka C++

Generické funkcie

Občas sa zíde napísať algoritmus, ktorý by mohol pracovať na dátach rôznych typov. Napríklad triediť môžeme celé alebo desatinné čísla, reťazce, zložitejšie štruktúry s určitým kľúčom a pod.

V C++ sa dajú písať takzvané generické funkcie, ktoré možno „parametrizovať” podľa typu:

#include <iostream>
using namespace std;

template <typename T> 
T vratPrvok(T *a, int k) {
    T result = a[k];
    return result;
} 

int main(void) {
    int a[5] = {1,2,3,4,5};
    cout << vratPrvok(a, 1) << endl;  // vypise 2

    return 0;
}

• Viac v letnom semestri.

Preťaženie operátorov

Pre novovytvorené typy je možné štadardným operátorom jazyka C++ priradiť novú sémantiku pomocou tzv. preťaženia. Napríklad v nasledujúcom príklade definujeme operátor < na menách, ktorý najprv porovnáva podľa priezviska a následne 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íklad operátory + a * pre štruktúry reprezentujúce polynómy alebo komplexné čísla...
• cout << "Hello" používa preťažený operátor << pre výstupný prúd na ľavej strane a reťazec na pravej strane.

Reťazce typu string

• V C++ je možné okrem klasických C-čkových reťazcov použiť aj typ string z C++.
• Jeho použitie je elegantnejšie, sám si určuje potrebnú veľkosť pamäte.
• Reťazce tohto typu sú objekty, do funkcií ich odovzdávame väčšinou referenciou.
• K jednotlivým znakom pristupujeme pomocou [] (ako u polí) alebo pomocou metódy at.

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

int main(void) {
    char cstr[100] = "Ahoj\n";
    string str = "Ako sa mas?\n";
    string str2;

    /* Do str mozno pomocou operatora = korektne priradit konstantne retazce,
       C-ckove retazce (polia znakov), aj ine premenne typu string. */
    str2 = "Ahoj\n";
    str2 = cstr;
    str2 = str;

    /* Meranie dlzky retazca: */
    cout << "Dlzka je: " << str.length() << endl;

    /* Funguje porovnanie pomocou ==, !=, <, ...
     * (bud dvoch C++ stringov, alebo C++ stringu a C stringu)
     * Pomocou operatora + mozno realizovat zretazenie. */
    str2 = cstr + str;
    str2.push_back('X');   // prida jeden symbol na koniec retazca
    str2.push_back('\n');
    cout << str2 << endl;

    if (str < str2) {
        cout << "Prvy je mensi" << endl;
    } else if (str == str2) {
        cout << "Rovnaju sa" << endl;
    } else {
        cout << "Druhy je mensi" << endl;
    }
    return 0;
}

• Pomocou metódy c_str() možno získať z reťazca typu string premennú typu const char*.

Štruktúra vector

Súčasťou štandardnej knižnice jazyka C++ je viacero rôznych dátových štruktúr. Ide pritom o generické štruktúry, ktoré môžu uchovávať dáta rôznych typov (čo je o poznanie elegantnejšie riešenie, ako to naše s dataType; v jednom programe napríklad môžeme mať štruktúry uchovávajúce rôzne typy).

Na tomto mieste spomeňme dátovú štruktúru vector [2]:

• O niečo podarenejšia verzia dynamických polí z prednášky.
• Deklarovať ho možno jedným z nasledujúcich spôsobov:

vector<int> a;       // vytvori pole celych cisel
vector<int> a(10);   // vytvori pole 10 celych cisel, ktore vsetky nastavi na vychodziu hodnotu
vector<int> a(5,1);  // vytvori pole 5 celych cisel, ktore nastavi na 1

• Prístup k prvkom vector-u je možný dvoma spôsobmi:
  • Klasicky pomocou a[index] – podobne ako pri poliach sa ale v takom prípade nekontroluje rozsah.
  • Alternatívne možno použiť a.at(index) – v prípade indexu mimo rozsahu program hneď spadne (presnejšie vyhodí výnimku) a nenarobí chaos v pamäti.
• V obidvoch prípadoch môžeme aj priraďovať: a[index] = value; a.at(index) = value;

• Ďalšie metódy na prácu s vector-mi:
  • a.push_back(x) vloží hodnotu x ako nový prvok na koniec poľa, podľa potreby pritom pole realokuje 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 východziu hodnotu.
  • a.capacity() vráti dĺžku aktuálne alokovaného poľa (môže sa líšiť od počtu prvkov v poli) a a.reserve(n) umožňuje objem alokovanej pamäte zväčšiť (väčšinou sa o tieto implementačné detaily nestaráme, vhodné použitie týchto funkcií však občas môže vykonávanie programu zefektívniť).

#include <vector>
using namespace std;

vector<int> a;
for (int i = 0; i <= 10; i++) {
    a.push_back(i);
}
for (int i = 0; i <= a.size() - 1; i++) {
    cout << a[i] << endl;  // alebo a.at(i)
}