Bevezetés a C ++ rekurzív funkcióba
A C ++ rekurzív funkcióval kezdve már ismertük a C ++ funkciók mögöttes ötletét, amely magában foglalja a függvény meghatározását, hogy más funkciókat is hívjunk. És ez a cikk a rekurzív definíció mögött meghúzódó fogalomra, a játék eszköz koncepciójára a matematikában és a programozási logikára vonatkozik. Egy ismert példa magában foglalja egy szám faktorialitását, az „n” természetes számok összegét stb. Egy olyan funkció, amely önmagában hív, rekurzív funkciónak nevezik. Csak egy olyan funkció, amelyre többször hivatkoznak. A rekurziónak van egy problémamegoldó eszköze, ahol a nagyobb problémákat egyszerű feladatokra osztja és külön-külön kidolgozza az egyedi sorrend követése érdekében.
Az adatszerkezetek olyan fogalmak, mint a fa keresése, rendezése, áthaladása, a rekurzív függvényt használják megoldásaihoz. Ez a programozási technika megkönnyíti a kódot. Az iteráció és a rekurzió egyaránt ugyanazt a folyamatot hajtja végre, mint a kód ismétlése, de a rekurzió különbsége az, hogy egy adott részt maga az alapfunkcióval hajtanak végre. Ebben a cikkben részletesen bemutatjuk a rekurzió fontosságát és azok működési folyamatát.
A rekurzív függvény szintaxisa a C ++-ban
A rekurzív függvény általános szintaxisa a c ++ szerint a következő:
return type function name((arguments))
(
Body of the statements;
function name ((actual arguments)) // recursive function
)
Hogyan működik a rekurzív funkció a C ++-ban?
A rekurzió megismétli a funkcióhívásokat, és leállítja a végrehajtást, amikor az alapeset valóra válik. A rekurzív függvényben meg kell határozni az alaphelyzet feltételét a stack túlcsordulási hibaüzenet elkerülése érdekében. Ha nincs meghatározva alapelv, akkor végtelen rekurzióhoz vezet. Amikor egy függvényt meghívnak, akkor minden egyes halomban egymásba tolja őket, hogy megismételjék az erőforrásokat minden ismétlődő híváshoz. Ez a legjobb a fa áthaladásakor. A rekurziónak két különféle típusa van: Közvetlen és közvetett rekurzió.
Közvetlen rekurzív: Illusztráció
int fibn(n)
(
fib(n);
)
void main ()
(
fib(n);
)
A fenti formátum a közvetlen rekurzív hívás, ahol azonnal felhívja / önmagában hívja. Vegyünk egy második típusú indirekt rekurziót, amely egy másik függvényhívást is magában foglal. Az alábbi ábrán tekinthető meg:
Közvetett rekurzív: Ábra
void f(int n) (
f1();
return;
)
void f2( int n) (
f();
return;
)
void f1() (
f2();
return;
)
Példák a C ++ rekurzív funkcióra
Az alábbi programban láthatja annak a programnak a végrehajtását, amelyet az alapértelmezett alapfeltétel mellett biztosítottam. Időnként az if-else feltétel használata a rekurzióban segít megelőzni a végtelen rekurziót. A kód folyamatát a közbenső rész részleges oldatával végezzük, és ezeket kombináljuk a végső megoldásig egy farok-rekurzió során.
1. példa
Íme egy egyszerű példa egy szám Fibonacci sorozatára. Az alábbi program tartalmaz egy hívást a rekurzív funkcióhoz, amelyet fib (int n) -ként definiálnak, amely a felhasználótól veszi be az adatokat, és 'n' -ben tárolja. A következő lépés magában foglalja a hurok bevételét a fib () függvénynek átadott kifejezés előállításához, amely visszatér a Fibonacci sorozathoz. Az alapesetet az if állítással állíthatjuk be, azaz az 1. vagy 2. szám ellenőrzésével nyomtathatjuk ki az első két értéket. végül ez a rekurzív funkció folytatódik a hurokkal az 1, 1, 2 sorozat kinyomtatásához.
Kód:
#include
using namespace std;
int fib_r (int s)
(
if(s==1||s==2)
return 1;
else
return (fib_r(s-1) +fib_r(s-2)); // fib(n-1) + fib(n-2) for adding successive terms
)
int main ()
(
int k, n;
cout<<"Enter no.of n terms: ";
cin>>n;
cout<<" calculated fibonacci numbers are"< for (k=1; k<=n; k++)
cout< return 0;
)#include
using namespace std;
int fib_r (int s)
(
if(s==1||s==2)
return 1;
else
return (fib_r(s-1) +fib_r(s-2)); // fib(n-1) + fib(n-2) for adding successive terms
)
int main ()
(
int k, n;
cout<<"Enter no.of n terms: ";
cin>>n;
cout<<" calculated fibonacci numbers are"< for (k=1; k<=n; k++)
cout< return 0;
)#include
using namespace std;
int fib_r (int s)
(
if(s==1||s==2)
return 1;
else
return (fib_r(s-1) +fib_r(s-2)); // fib(n-1) + fib(n-2) for adding successive terms
)
int main ()
(
int k, n;
cout<<"Enter no.of n terms: ";
cin>>n;
cout<<" calculated fibonacci numbers are"< for (k=1; k<=n; k++)
cout< return 0;
)
Kimenet:
2. példa
A palindrom számának ellenőrzése rekurzív funkcióval.
Kód:
#include
using namespace std;
int palim(int a, int t)
(
if (a == 0)
return t;
t = (t * 10) + (a % 10);
return palim(a / 10, t);
)
int main()
(
int n;
cout<>n;
int result = palim(n, 0);
if (result == n)
cout << "Number "< else
cout << "Number "< return 0;
)#include
using namespace std;
int palim(int a, int t)
(
if (a == 0)
return t;
t = (t * 10) + (a % 10);
return palim(a / 10, t);
)
int main()
(
int n;
cout<>n;
int result = palim(n, 0);
if (result == n)
cout << "Number "< else
cout << "Number "< return 0;
)#include
using namespace std;
int palim(int a, int t)
(
if (a == 0)
return t;
t = (t * 10) + (a % 10);
return palim(a / 10, t);
)
int main()
(
int n;
cout<>n;
int result = palim(n, 0);
if (result == n)
cout << "Number "< else
cout << "Number "< return 0;
)
Kimenet:
3. példa
Programozzon véletlenszám-generátorral.
Kód:
#include
#include
#include
#include
using namespace std;
int rand1(int n);
int main () (
int n, j;
int r;
srand(time (NULL));
cout << "Enter number of dice: ";
cin >> n;
for (j = 1; j <= n; j++) (
r = rand1(5) + 1;
cout << r << " ";
)
system("PAUSE");
return 0;
)
int rand1(int n) (
return rand () % n;
)
A fenti program egy véletlenszám-generátort szemléltet, amikor a kocka véletlenszerűen gördül. A Rand1 (int n) függvény meghívásával hajtják végre, és 0-tól n-1-ig terjedő számokat generálnak. és a vetőmag értékét null értékkel állíthatja be (nincs cím). Például, ha 4-be írunk, akkor a kocka esélye 5, 4, 1, 2 lesz.
Kimenet:
Vannak olyan fogalmak is, mint egy lineáris keresés, közös osztó és egy adott szám legfontosabb tényezője, amely rekurzív megvalósítást használ.
A rekurzió előnyei
- Az általuk nyújtott kód tiszta és kompakt, a nagyobb komplex program egyszerűsítésével. Kevesebb változót használ a programkódban.
- Itt elkerülhető a komplex kód és a hurkokba beágyazott szöveg.
- A kód valamelyik része visszamenőleges követést igényel, amelyet rekurzív módon oldunk meg.
A rekurzió hátrányai
- Több memóriaelosztást igényel az összes funkcióhívás veremművelete miatt.
- Néha lassabban teljesít, miközben végrehajtja az iterációs folyamatot. Ezért a hatékonyság kevesebb.
- A kezdőknek nehéz megérteni a működést, mivel a kód néha mélyrehatóbbá válik. ha a helyből kikerül, és végül a program összeomlik.
Következtetés
Ezzel megvitattuk a c ++ függvények működését és rekurzív módon meghatározását. És áttekintettük a levelezést és azok rekurzív funkciójának előnyeit és hátrányait a programozási világban. Ezt követően megmutattuk, hogyan lehet megvalósítani a C ++ programban egy rekurzív függvénydefinícióval. Továbbá arra a következtetésre jutunk, hogy a rekurzió a C ++ esetében segít megoldani az adatszerkezet-koncepciók, például átjárások, rendezés és keresés problémáit, és hatékonyan használható, ahol csak szükséges.
Ajánlott cikkek
Ez egy útmutató a C ++ rekurzív funkciójához. Itt tárgyaljuk, hogyan működik a rekurzív függvény a C ++-ban, a szintaxis, a különféle példák és a kód implementációja. A következő cikkeket is megnézheti további információkért -
- Mi a C ++ tömb funkció?
- A C ++ karakterlánc funkciók áttekintése
- Legjobb C ++ fordító (példák)
- Bevezetés a C ++ parancsokba
- Fibonacci sorozat Java-ban
- Véletlenszám-generátor a Matlab-ban
- Véletlenszám-generátor C # -ben
- Palindrom C ++ -ban
- Véletlenszám-generátor a JavaScript-ben
- A C ++ 11 legfontosabb tulajdonságai és előnyei
- Ismerje meg a PHP tömbfunkcióinak típusait