Rekurziónál mi történik pontosonan lépésről lépésre?
#include <iostream> using namespace std;
int fib (int x)
{
cout<<"fib: "<<x<<endl; if ( (x==1) || (x==0) )
{
cout<<"if cella"; cout<<"x: "<<x<<endl; return (x) ;
}
else
{
return (fib (x1)+fib(x2)) ;
}
}
int main ()
{ cout << " " << fib (7) ;
return 0;
}
Erre a kimenet:
fib: 7
fib: 6
fib: 5
fib: 4
fib: 3
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib:1
x: 1
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 3
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 1
x: 1
fib: 4
fib: 3
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 1
x: 1
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 5
fib: 4
fib: 3
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 1
x: 1
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 3
fib: 2
fib: 1
x: 1
fib: 0
x: 0
fib: 1
x: 1 13
Hogy van az hogy a függvény meghívja magát x=1 értékre,majd belép az if es szerkezetbe kiirja if cella meg x értékét,majd a returnál ahelyett hogy vége lenne folytatódik valahogy furán.
Az is érdekelne hogy hogy van az ,annyi az eredmény mindig ,ahány x=1 re érkező függvényhívás történik.
Köszi
válasza:Az x1 és x2 honnan van? Lehet, csak én nem veszem észre
Csak hogy átlássam valamennyire, mit kell csinálnia a programnak? Mármint a fib az mire utal?
válasza: válasza:Szerintem egy fa elemeinek a kiírásával lehet legjobban megérteni, vagy az n faktoriális számításával.
Vegyünk egy fát (egy csomópontnak max 2 leszármazott eleme lehet), így képzelj el egyet:
C-ben egy csomópontja (az ábrán egy betű egy körben):
struct csp { // "csomópont"
char b; // betű a körben
struct csp *bal, *jobb; // a bal és a jobb oldali leszármazott eleme
}
A feladat kiíratni a fa minden elemének a betűjét (a char sz;).
Hogyan járnánk be a fát? Ciklussal nem lehet, mert elágazások vannak benne.
Ekkor használunk rekurziót: olyan függvényt írunk, amiben meghívjuk saját magát.
Így pl:
void kiir (struct csp* p) {
cout << p.b << endl;
if (p.bal != NULL) kiir(p.bal);
if (p.jobb) kiir(p.jobb); // szándékosan nem írtam le a != NULL részt, nem szükséges, elvégre ha valami nem NULL ("semmi"), akkor az valami, ami "igaz" logikai értéket képvisel, a feljebbinél is elhagyható
}
int main () {
struct csp q, r, s, t, u;
q.b = 'z';
r.b = 'e'
s.b = 'j';
t.b = 'd';
u.b = 'y';
q.bal = &r; // r memóriacíme
q.jobb = &u; // u memóriacíme
r.bal = &s; // s memóriacíme
r.jobb = &t; // t memóriacíme
s.bal = NULL; // "semmi", nincs következő elem
s.jibb = NULL; // ...
t.bal = NULL;
t.jibb = NULL;
u.bal = NULL;
u.jibb = NULL;
kiir(&q); // az 1. "láncszem" memóriacímét adjuk meg (a fa "gyökerét"), innen kezdve fut neki a fának a rekurziós ("rekurzív") függvény (az ábrán lefelé haladva kell elképzelni).
}
További kérdések:
Minden jog fenntartva © 2024, www.gyakorikerdesek.hu
GYIK | Szabályzat | Jogi nyilatkozat | Adatvédelem | Cookie beállítások | WebMinute Kft. | Facebook | Kapcsolat: info(kukac)gyakorikerdesek.hu
Ha kifogással szeretne élni valamely tartalommal kapcsolatban, kérjük jelezze e-mailes elérhetőségünkön!