Natrefí-li Karel v těle procedury na volání neatomického příkazu (tj. čehokoliv kromě KROK, VLEVO VBOK, POLOŽ a ZVEDNI), „odskočí“ si do definice tohoto neatomického příkazu, aby se po jeho vykonání zase vrátil zpátky a pokračoval ve vykonávání příkazu původního. Příklad:

Je zjevné, že při odskoku do procedury ČELEM VZAD si Karel musel zapamatovat, na jaké místo se má vrátit, aby dokázal dokončit příkaz VPRAVO VBOK. Přitom po návratu do procedury VPRAVO VBOK už zase mohl tuto informaci zapomenout.

Co kdybychom ale v těle procedury zavolali tu samou proceduru? Jako třebas:

V tomto případě začne Karel vykonávat příkaz PIRUETA, který mu nejdříve předepisuje otočit se VLEVO VBOK. Karel se tedy poslušně otočí vlevo vbok a podívá se dál. Tam na něj ale čeká podivnost – znovu začít vykonávat příkaz PIRUETA? Dřív než provádění aktuálního příkazu doběhlo do konce? Nu, co se dá dělat – jak je psáno, tak je dáno. Karel tedy poslušně odskočí z prostředka právě vykonávaného příkazu a zavolá další piruetu. A v ní má předepsáno, že se má otočit doleva. Tak se tedy poslušně otočí a podívá se, co má dělat dál... Přibližně podle následujícího schématu:

Na první pohled to možná vypadá jako nesmysl, ale uvedený program skutečně funguje – Karel se točí pořád doleva a nikdy sám od sebe nepřestane^*, musíme ho zastavit ručně klikem na červený křížek v knihovně známých příkazů.

PS: Někdy se toto chování může hodit, ale většinou spíše ne. Zjevně by se nám tedy v obecném případě hodila nějaká podmínka, která zajistí, že řetězec nekonečných volání se někdy ukončí.

Uvedené technice, kdy příkaz volá sám sebe – tedy je v podstatě nadefinován sám sebou – se odborně říká rekurze. (Stejně jako v matematice, kde je rekurzivní zadávání nejrůznějších posloupností zcela běžné.) Přitom:

• je-li příkaz definován sám sebou, mluvíme o tzv. přímé rekurzi;
• pokud je volání příkazu schováno v posloupnosti volání dalších příkazů, nazývá se taková rekurze nepřímou.

Na první pohled to trochu vypadá jako nějaká děsivá a zakázaná definice kruhem a vlastně skoro i je, ale funguje to a spousta problémů se pomocí rekurze popisuje velmi snadno. Navíc v případě našeho Karla, který neobsahuje žádné tzv. proměnné, nám rekurze umožňuje tento „nedostatek“ obejít a dokonce Karla jistým způsobem naučit počítat, jak si v dalším ukážeme.

Když Karel z vnitřku procedury volá proceduru jinou, musí si zapamatovat příslušné návratové informace. Je zjevné, že v případě rekurze z předchozího slajdu se paměť bude (může) plnit nikdy neodstraněnými údaji:

Zjevně při každém rekurzivním volání si Karel musí zapamatovat návratové informace do volání předchozího – z druhé pirety se musí umět vrátit do první, ze třetí do druhé a tak dál. A jelikož definice procedury PIRUETA neobsahuje žádnou ukončovací podmínku, bude si muset těchto informací pamatovat čím dál tím více... Nebo ne?

Obecně některé programovací jazyky dokáží vyhodnotit takto specifická rekurzivní volání jako nenávratová a žádné návratové informace ani nebudou zaznamenávat, protože přijdou na to, že je to zbytečné. Rozhodně na to však nesázejte ^_^

Každopádně nenávratová rekurze v Karlovi zas tolik použití stejně nemá, daleko častěji se z rekurze po splnění nějaké podmínky budeme chtít začít vracet po jednotlivých voláních zpátky. Každý návrat do předchozího volání umaže z tabulky návratových hodnot další informaci (podobně jako když jsme se po vykonání příkazu ČELEM VZAD vrátili zpátky do procedury VPRAVO VBOK) a počet zaznamenaných návratových dat se tak bude postupně snižovat, až se po návratu na počátek rekurzivního volání (samozřejmě neopustíme-li ho z nějakého jiného důvodu dříve) sníží na nulu.

Dostaňme s Karlem za úkol přenosit značky z aktuálního pole na pole následující. S rekurzí vypadá řešení na první pohled možná až magicky, ale už na druhý je vlastně celkem přirozené:

Co se v tomto případě děje? Zkusme si to pro případ dvou značek na výchozím poli (abychom se neukreslili) rozepsat do nám již známého schématu:

Tohle už je složitější, tak si to probereme postupně:

1. Při prvním zavolání příkazu/procedury PŘENES[R] Karel zjistil, že na políčku je nějaká značka (zatím jsou tam dvě), proto se aktivovala část rozhodovacího příkazu KDYŽ JE ZNAČKA. V ní Karel poslušně jednu značku zvedl (ZVEDNI) a vzápětí narazil na rekurzivní volání procedury PŘENES[R]. Proto ji zavolal (viz druhý sloupec PŘENES[R](2)).
2. Nyní je Karel opět na začátku procedury, tedy u podmínky KDYŽ JE ZNAČKA. Jelikož je na políčku ještě pořád značka (tentokrát už poslední), opět se aktivuje stejná část rozhodovacího příkazu a Karel poslušně jednu značku zvedne (ZVEDNI) a stejně jako předtím narazí na další rekurzivní volání procedury PŘENES[R]. Proto ji zavolá (viz třetí sloupec PŘENES[R](3)).
3. Ve třetím rekurzivním volání již podmínka JE ZNAČKA splněna není – Karel obě značky již zvedl v předchozích dvou voláních procedury PŘENES[R]. Karel proto zaběhne do druhé větve rozhodovacího příkazu, tj. JINAK. Zde má předepsaný KROK, proto ho poslušně udělá (čímž se posune o jedno pole před sebe).
4. Nyní se začne uplatňovat návrat z rekurzivních volání. Karel dokončí aktuální příkaz PŘENES[R](3) a vrátí se do předchozího rekurzivního kroku PŘENES[R](2) na místo, ve kterém ho opustil, tzn. za příslušné volání PŘENES[R].
5. Zde má předepsáno položit značku (POLOŽ), proto ji položí. Tím ovšem končí zpracování větve KDYŽ JE ZNAČKA, Karel proto ukončí i tento příkaz PŘENES[R](2) (větev JINAK se ve druhém rekurzivním volání nemůže uplatnit, protože podmínka nebyla splněna) a vrátí se do předchozího rekurzivního kroku PŘENES[R](1) na místo, ve kterém ho opustil, tzn. za příslušné volání PŘENES[R].
6. Zde ho čeká opět příkaz k položení značky POLOŽ, což udělá, a následně již pouze úplný konec vykonávání příkazu PŘENES[R], protože ze stejných důvodů jako v předchozím kroku se větev JINAK nezavolá.

V důsledku se část příkazů před rekurzivním voláním (zde ZVEDNI) provede stejným počtem krát, zde tedy dvakrát, jako část příkazů za rekurzivním voláním (zde POLOŽ) a Karel tedy nejdříve značky vysbírá, aby jich poté o políčko dál (aktivace větve JINAK–KROK–KONEC) zase stejný počet položil.

Poučení z této lekce o rekurzi jsou dvě a obě jsou velmi důležitá, takže si je zapište za uši:

• Část za rekurzivním voláním se provádí stejným počtem krát, jako část před ním. Pokud se do toho nenabouráte nějakou dodatečnou podmínkou.
• V některém z rekurzivních kroků musí podmínka zajistit, že k dalšímu rekurzivnímu volání již nedojde. V našem příkladu došly na prvním políčku značky, což testovala podmínka KDYŽ JE ZNAČKA.

Podmínka, která rozhoduje o tom, zda v dalším kroku opět zavoláme rekurzi, nebo se z ní začneme vracet zpět k prvnímu volání, se odborně nazývá kotva rekurze. Je vlastně tím, co mění nekonečnou rekurzi na konečnou (tedy „ukotvenou“ :-).

V místě, kde se kotva rekurze uplatní, tedy v druhé větvi podmínky, může být libovolný kód. (V případě potřeby dokonce i žádný!) Což má samozřejmě nejrůznější použití. Kupříkladu Karel v předchozím příkladu nemusí přenosit značky jen o políčko dál, ale třebas o dvě nebo tři:

Je důležité si uvědomit, že blok s podmínkou (ze stejného příkladu)..

..se totiž vždy provede celý, ale každá z jeho dvou částí v jinou dobu! Pokud je podmínka postupně splněna třebas n-krát, tak nejdříve se n-krát provede část kódu před rekurzivním voláním (zde ZVEDNI) a teprve potom se také n-krát provede část kódu po něm (zde POLOŽ).

Ve výsledku sice Karel neumí počítat s čísly, ale zato ví, že celý kód v bloku před rekurzivním voláním se provede stejněkrát jako celý kód v bloku za rekurzivním voláním a že tam dokonce některá z těchto částí ani nemusí být (n-krát se pak v podstatě provádí nic). A to je vlastnost doslova k nezaplacení, jak si ukážeme v dalších příkladech.

Následující použití rekurze pro naučení Karla jak dojít do poloviny vzdálenosti mezi ním a stěnou, ke které je natočen, vypadá na první pohled doslova magicky. Ale po vysvětlení z předchozího slajdu je vlastně zcela přirozené. Zkusme k němu dojít po jednotlivých krocích – co musí Karel udělat, aby došel do poloviny vzdálenosti?

Jako programátor můžeme podvádět a podívat se, kolik políček Karlovi ke stěně zbývá, a pak jednoduše napsat cyklus s příslušným počtem opakování kroků. To je ovšem těžce neuniverzální řešení, protože stačí Karla postavit do jiné vzdálenosti a náš algoritmus beznadějně selže. Musíme na to tedy jinak.

Kdyby Karel uměl počítat, nechali bychom ho dělat kroky směrem ke stěně a počítali bychom, kolik jich udělal. Potom už bychom se jednoduše o polovinu z nich vrátili zpátky. Tohle by pravděpodobně bylo řešení, které byste použili pro podobný problém v mnoha jiných jazycích. Náš Karel však počítat neumí (neobsahuje žádné proměnné, jejichž hodnotu bychom mohli postupně upravovat), takže na to musíme jinak.

Ale pozor, právě jsem si přece ukázali, že jistým způsobem Karel počítat přeci jen nějak umí – část příkazů (ze stejného bloku) před rekurzivním voláním i po něm se provede stejný počet krát! Pravda, nevíme kolikrát se tyto části provedou, jen víme, že oba počty budou stejné... Ale – nestačí nám to už?

Vzpomeňmě si na předchozí návrh řešení – dojít ke stěně a pak se vrátit o polovinu počtu kroků zpátky. Nešlo by tohle nějak zařídit rekurzí? Chceme vlastně po Karlovi, aby po rekurzivním volání udělal dvakrát méně kroků než před ním... Jelikož půlkrok udělat neumíme (Karel se dokáže vždy posunout pouze o celé políčko) a musíme se tedy vracet po jednom celém kroku, jak dosáhneme požadovaného efektu? Ano, správně – dopředu (směrem ke stěně) půjdeme vždy o kroky dva! Tím dosáhneme přesně žádaného – Karel při cestě zpátky udělá vždy jeden krok na každé dva kroky při cestě tam.

Rekurze však musí někdy skončit a začít se vracet na začátek. V tomto případě je to jednoduché – Karel se zarazí a začne vracet ve chvíli, kdy dojde ke zdi. Použijeme tedy podmínku ZEĎ. Navíc musíme ovšem ještě počítat s tím, že Karel by mohl nepozorným krokem nabourat do zdi, celé řešení bude proto vypadat následovně:

Rozkresleme si opět, jak bude vypada průběh programu v případě, že Karel stál na začátku na pátém políčku od zdi:

Průběh výpočtu (provádění programu) je tedy následující:

1. Na začátku stojí Karel na pátém políčku od zdi. Podmínka KDYŽ NENÍ ZEĎ je tedy splněna a Karel udělá poslušně dva kroky dopředu (první KROK „natvrdo“, protože víme, že nestojí před zdí, druhý KROK? bezpečně, protože se předchozím krokem ke zdi dostat mohl). Následně rekurzivně zavolá sám sebe (PŮLKA(2)).
2. Druhé volání procedury PŮLKA(2) začíná opět podmínkou KDYŽ NENÍ ZEĎ. Jelikož Karel teď stojí na třetím políčku od zdi, udělá opět dva kroky (KROK a KROK?), čímž se dostane na první políčko před zdí a zavolá znovu sám sebe (PŮLKA(3)).
3. Při třetím rekurzivním volání procedury PŮLKA(3) už podmínka KDYŽ NENÍ ZEĎ splněna nebude – Karel totiž už stojí přímo před zdí. Procedura se tudíž rovnou ukončí (není zde žádná větev JINAK, která by se mohla aplikovat) a rekurze se začne vracet na začátek.
4. Při prvním návratu do procedury PŮLKA(2) na Karla čeká vykonání jednoho příkazu ÚKROK VZAD, čímž se posune o jedno políčko zpátky na druhé pole od zdi. Následně procedura PŮLKA(2) končí a po rekurzi se vracíme do předchozího kroku.
5. Nyní už jsme v prvním volání PŮLKA(1), kde na Karla čeká další příkaz ÚKROK VZAD, kterým se dostane na třetí políčko od zdi, a po něm už úplný konec vykonávání příkazu PŮLKA.

PS: Je jasné, že Karel provede celý počet dvoukroků dopředu pouze tehdy, bude-li mezi ním a zdí právě sudý počet políček. Jinak udělá dopředu právě o jeden krok méně a dozadu se tudíž vrátí jaksi o jedno pole dál, než by to na první pohled mělo být. Lichý počet polí prostě na celé poloviny nerozložíme, takže to tak dopadnout musí.

Pokud rekurze neobsahuje žádnou podmínku, na kterou by skončila, stává se nekonečnou:

Všimněte si především, že v obou příkladech je rekurzivní volání posledním, které se z každé iterace programu vykoná, a Karel se pak na toto místo již nikdy nevrátí! Pokud by za ním byl nějaký kód, nebude se nikdy provádět. Není vůbec problém něco takového přehlédnout a pak se divit, proč se náš program chová úplně jinak, než jsme si vymysleli.

Mějme za úkol vybrat z pole, na kterém Karel stojí, všechny značky:

Karel jednoduše zvedne značku, pokud na políčku nějaká je, a rekurzí to bude dělat tak dlouho, dokud je všechny nevysbírá. Tím se rekurze ukončí (podmínka JE ZNAČKA již nebude nadále splněna) a vrátí se postupně do všech předchozích volání. A jelikož po rekurizvním volání již žádný další kód nenásleduje, program spořádaně skončí.

Úplně stejně se dá vyřešit opačný problém – pole značkami prozměnu zaplnit:

Karel prostě rekurzivně stále pokládá značky, dokud se na políčko ještě nějaké vejdou. Jakmile je pole plně obsazeno (tedy podmínka JE MÍSTO již nadále není pravdivá), vrátí se rekurzivní volání postupně zpět a program se ukončí.

Nyní zkusme pomocí rekurze dojít s Karlem ke zdi. A rovnou vícero variantami:

První varianta je asi nejpřímější a zcela v duchu předchozích příkladů. Nicméně především ta třetí, s obrácenou podmínkou, stojí za pozornost – dosti často se totiž stává, že problém, který je s nějakou podmínkou těžko řešitelný, se může ukázat mnohem snadnější s podmínkou opačnou (pokud je možno řešení příslušným způsobem obrátit). Zkuste si to zapamatovat, třeba se vám to někdy bude hodit.

S rekurzí můžeme řešit novou velkou celou třídu problémů (v podstatě by se dalo říct, že Karel bez rekurze by ani nebyl Karel, protože by spoustu věcí nedokázal). Podobně jako dřív si také vyřešíme některé starší úlohy jiným způsobem, pomocí rekurze.

Pořádná rekurzivní zadání:

1. Postavte Karla do dvojnásobné vzdálenosti od zdi. (Přímá aplikace příkladu ze slajdů, jen opačným směrem ^_~)
2. Ještě jednou na podobné brdo – posuňte Karla do třetinové vzdálenosti k nejbližší zdi. (Třetina blíže ke zdi.)
3. Když už teď umíte rekurzi, vyražte s Karlem směrem, kterým je otočený, a zastavte se na nejbližší značce, aniž byste při tom nabourali do zdi.
4. Zopakujte si předchozí úlohu, ale zkuste s Karlem projít celou řádku či sloupec. (Tedy nenatrefí-li Karel na značku směrem tam, u zdi se otočí a zkusí ji najít ještě směrem zpět. To pro případ, že byla na začátku za jeho zády.)
5. Udělejte s Karlem tolik kroků, na kolika značkách stojí. Značky při tom zrušte.
6. Dojděte s Karlem ke zdi a na poslední pole postavte tolik cihel (značek :-), kolik jste ušli kroků.
7. Dojděte s Karlem ke zdi a zpět na výchozí pole.
8. Dojděte s Karlem do středu (prázdného) města.
9. Zinvertujte počet značek na aktuálním poli. (Tedy byly-li na políčku značky tři, po vykonání příkazu jich tam bude pět a naopak.)
10. Přesuňte Karla tak, aby se prohodily vzdálenosti ke zdi před ním a za ním. (Tedy je-li na začátku před Karlem políček šest a za ním tři, po provedení příkazu jich bude šest za ním a před ním tři.)
11. Postavte na pole před Karlem tolik značek, kolik jich je na výchozím poli. Přitom:
    • Značky na výchozím poli zrušte.
    • Značky na výchozím poli zachovejte.
12. Prohoďte počty značek na dvou sousedních polích. (Za sousední pokládejte aktuální a to před ním, ať si vystačíme pouze s krokem dopředu a dozadu.)
13. Nechť je na výchozím poli několik značek. Postavte s Karlem na každé další pole o jednu značku méně (aneb postavte schody).
14. Dojděte s Karlem ke zdi, položte u ní minu (tj. značku ^_^) a vraťte se zpátky na startovní pole. Přitom:
    • Neznačkujte cestu.
    • Na každé pole cestou položte jednu značku.
15. Dojděte s Karlem na první pole, kde je víc než jedna značka. (Asi budete potřebovat i příkaz STOP.)

Variace na cykly a podmínky:

1. Obcházejte s Karlem donekonečna po obvodu města.
2. Projděte s Karlem celé město z DOMOVA řádku po řádce.
3. Postavte šachovnici. (Žádná značka představuje bílé pole, jedna značka černé. Město je na začátku prázdné.)
4. Zinvertujte šachovnici z předchozího kroku. (Tedy prohoďte černá a bílá pole.)
5. Nechť je na začátku Karel na libovolném políčku v prázdném městě natočený libovolným směrem. Nechť je domov umístěn na libovolném políčku ve městě. Dojděte s Karlem do domu.