Tartalom

• Összehasonlító táblázat
• A rekurzió meghatározása
• Az iteráció meghatározása
• Következtetés:

A rekuráció és az iteráció ismételten végrehajtja az utasításokat. A rekurzió az, amikor egy függvény egy állítása többször felhívja magát. Az iteráció az, amikor egy hurok ismételten végrehajtódik, amíg a vezérlő feltétel hamis lesz. A rekurzió és az iteráció elsődleges különbsége az, hogy a rekurzió egy folyamat, amelyet mindig egy függvényre alkalmaznak. A ismétlés az utasításkészletre vonatkozik, amelyet többször végrehajtani akarunk.

1. Összehasonlító táblázat
2. Meghatározás
3. Főbb különbségek
4. Következtetés

Összehasonlító táblázat

Az összehasonlítás alapja	rekurzió	Ismétlés
Alapvető	A függvény egy állítása maga a függvényt hívja.	Lehetővé teszi az utasítások sorozatának többszöri végrehajtását.
Formátum	Rekurzív függvényben csak a befejezési feltételt (alapesetet) adják meg.	Az iteráció magában foglalja az inicializálást, a feltételt, az utasítás végrehajtását a hurkon belül és a vezérlőváltozó frissítését (növekmények és csökkentések).
befejezés	A függvény törzsébe feltételes kijelentés kerül, amely arra kényszeríti a funkciót, hogy visszatérjen anélkül, hogy rekurziós hívást hajtana végre.	Az iterációs nyilatkozatot ismételten végrehajtjuk, amíg egy bizonyos feltétel teljesül.
Állapot	Ha a függvény nem konvergál valamilyen feltételhez, amelyet úgy hívnak (alapeset), hogy végtelen rekurzióhoz vezet.	Ha az iterációs utasításban szereplő ellenőrzési feltétel soha nem válik hamisnak, akkor végtelen iterációhoz vezet.
Végtelen ismétlés	A végtelen rekurzió összeomolhatja a rendszert.	A végtelen hurok többször használja a CPU ciklusokat.
Alkalmazott	A rekurziót mindig a függvényekre alkalmazzák.	Az iterációt iterációs utasításokra vagy "hurkokra" alkalmazzák.
Kazal	A verem az új helyi változók és paraméterek halmazát tárolja minden alkalommal, amikor a függvényt meghívják.	Nem használ verem.
Felső	A rekurzió az ismételt funkcióhívások fölött rejlik.	Nincs fölösleges ismételt funkcióhívás.
Sebesség	Lassú végrehajtás.	Gyors végrehajtás.
A kód mérete	A rekurzió csökkenti a kód méretét.	Az ismétlés hosszabbítja a kódot.

A rekurzió meghatározása

A C ++ lehetővé teszi, hogy egy függvény hívja magát a kódján belül. Ez azt jelenti, hogy a függvény meghatározása rendelkezik függvényhívással. Néha „kör meghatározás„. A függvény által használt helyi változók és paraméterek halmaza újból létrehozásra kerül, amikor a függvény magát felhívja, és a verem tetején tárolódnak. De minden alkalommal, amikor egy funkció meghívja magát, nem hoz létre új másolatot a funkcióról. A rekurzív funkció nem csökkenti jelentősen a kód méretét, és még a memória kihasználtságát sem javítja, ám az iterációval összehasonlítva némi előnye van.

A rekurzió befejezéséhez a függvény meghatározásába be kell építeni egy kiválasztó nyilatkozatot, amely arra kényszeríti a funkciót, hogy visszatérjen anélkül, hogy önmagában rekurzív hívást kezdene. Ha a rekurzív függvény meghatározásában nincs kiválasztott utasítás, akkor a függvény végtelen rekurzióban lesz, ha egyszer meghívják.

Megértjük a rekurziót egy olyan függvénnyel, amely visszaadja a szám tényezőjét.

int faktorialis (int num) {int válasz; if (num == 1) {visszatér 1; } else {válasz = tényező (num-1) * num; // rekurzív hívás} visszatérés (válasz); }

A fenti kódban a másik részben szereplő állítás a rekurziót mutatja, mivel az utasítás azt a tényezőt hívja meg, amelyben található.

Az iteráció meghatározása

Az iterálás az utasításkészlet ismételt végrehajtásának folyamata, amíg az iterációs utasításban szereplő feltétel hamis lesz. Az iterációs utasítás tartalmazza az iterációs utasításban szereplő utasítások inicializálását, összehasonlítását, végrehajtását és végül a kontrollváltozó frissítését. A vezérlőváltozó frissítése után újra összehasonlítják, és a folyamat megismétlődik, amíg az iterációs utasításban szereplő feltétel hamisnak bizonyul. Az iterációs utasítások „for” hurok, „while” hurok, „do-while” hurok.

Az iterációs utasítás nem használ veremt a változók tárolására. Ezért az iterációs utasítás végrehajtása gyorsabb, mint a rekurzív függvénynél. Még az iterációs funkciónak nincs ismétlődő funkcióhívása, amely szintén gyorsabbá teszi a végrehajtását, mint a rekurzív funkció. Az iteráció akkor fejeződik be, amikor a vezérlő feltétel hamis. A kontrollfeltétel hiánya az iterációs utasításban végtelen hurkot eredményezhet, vagy fordítási hibát okozhat.

Megértjük az iterációt a fenti példa vonatkozásában.

int faktorialis (int num) {int válasz = 1; // inicializálásra van szükség, mert tartalmazhat egy szemetet az inicializálása előtt (int t = 1; t> num; t ++) // iteráció {válasz = válasz * (t); visszatérés (válasz); }}

A fenti kódban a függvény iterációs utasítás felhasználásával adja vissza a szám tényezőjét.

1. A rekurzió az, amikor egy programban szereplő módszer ismételten felhívja magát, míg az iteráció az, amikor a programban szereplő utasítások sorozatát többször végrehajtják.
2. A rekurzív módszer utasításokat, önmagát hívó utasításokat és egy befejezési feltételt tartalmaz, míg az iterációs utasítások inicializálást, növekedést, feltételt, utasításkészletet tartalmaznak egy hurkon belül és egy vezérlő változót.
3. Egy feltételes utasítás határozza meg a rekurzió befejezését, és a kontrollváltozó értéke dönt az iterációs utasítás megszüntetéséről.
4. Ha a módszer nem vezet a befejezési feltételhez, akkor végtelen rekurzióba kerül. Másrészt, ha a vezérlési változó soha nem vezet a végértékhez, akkor az iterációs utasítás végtelenül iterál.
5. A végtelen rekurzió rendszer összeomláshoz vezethet, míg a végtelen iteráció CPU ciklusokat vesz igénybe.
6. A rekurziót mindig a módszerre alkalmazzák, az iterációt pedig az utasításkészletre.
7. A rekurzió során létrehozott változókat veremben tárolják, míg az iterációhoz nincs szükség veremre.
8. A rekurzió okozza az ismételt funkcióhívás fölényét, míg az iterációnak nincs olyan funkciója, amely fölött hívja.
9. A függvényhívás miatt a rekurzió felső végrehajtása lassabb, míg az iteráció végrehajtása gyorsabb.
10. A rekurzió csökkenti a kód méretét, míg az iterációk hosszabbítják a kódot.

Következtetés:

A rekurzív függvényt könnyű írni, de az iterációhoz képest nem teljesítenek jól, míg az iterációt nehéz írni, de teljesítményük jó a rekurzióhoz képest.