Bevezetés a rekurzív funkcióba a C # -ben
A C # rekurzív funkcióban a rekurzió azt jelenti, hogy ugyanazt a jelentést jelenti, mint az angol nyelven, pontosan úgy nevezik, mint ismétlődés. Tehát egy funkció rekurzív jellege azt jelenti, hogy ugyanazt a munkát többször is elvégezzük. És igen, ha a programot nem kezelik helyesen, akkor mindenképpen folyamatos folyamatban futtatja a programot. Gondoskodnunk kell arról, hogy meghatározzuk a megfelelő feltételeket e rekurzív függvények végrehajtásához, különben a függvény újra és újra felhívná magát, ami a program folyamatos végrehajtásához vezetne. Most menjünk tovább és nézzük meg, hogyan lehet ezeket a funkciókat létrehozni a C # -ben.
A rekurzív függvények szintaxisa a C # -ben
A szintaxis itt megegyezik a C # alapfunkció szintaxisával. Nézzük meg itt.
Nincs itt speciális szintaxis, de megfigyelhetjük, hogy egy függvény maga hívja fel a visszatérési eredményt. És nagyon óvatosan kell átadnunk ezeket a paraméterértékeket a rekurzív függvénybe, mivel nyilvánvalóan nem akarunk futó kódot, amely nem áll le.
A fenti szintaxisban nincs ilyen, a függvényt csak visszatérő utasításokban kell meghívni. Inkább még egy rekurzív függvény visszatérési értéket is hozzárendelhetünk egy változóhoz, és azt is visszaadhatjuk.
A faktorizáció végrehajtása
Itt vesszük az alapértelmezett probléma-megállapítást, a faktorizálást, a rekurzív függvény előállításához.
Kód:
using System;
class First (
static void Main() (
int result;
result = fact(7);
Console.WriteLine("Factorial is : " + result);
)
public static int fact(int num)
(
if(num==0)
(
return 1;
)
return num*fact(num-1);
)
)
Vessen egy pillantást a lépésről lépésre.
- Először létrehoztuk a saját paraméterezett függvényét, amely a főfüggvényből bemeneti értéket vesz ki, amelyre ki akarjuk számítani a tényezőt.
- Ezután if feltételt készítettünk annak ellenőrzésére, hogy az adott szám nulla. Ha a szám nulla, akkor 1-et adunk vissza alapértelmezett értékként.
- Máskülönben a jelenlegi számot megszorozzuk azzal a függvénnyel, hogy paraméterként mínusz 1-et kapunk.
- Tehát ez a szorzás addig ismétlődik, amíg 0-ig nem kapunk. Mint alapértelmezés szerint a visszatérési eredményt nullára írtuk, mint 1, a végeredményt megszorozzuk 1-gyel.
Kimenet:
Most a kódban a funkcionális paramétert számom mínusz 1-ről számra cserélem. Ebben az esetben a funkció újra és újra felhívná magát, és a folyamat megismétlődik.
Kód:
using System;
class First (
static void Main() (
int result;
result = fact(7);
Console.WriteLine("Factorial is : " + result);
)
public static int fact(int num)
(
if(num==0)
(
return 1;
)
return num*fact(num);
)
)
Kimenet:
A fenti kimeneten keresztül világosan láthatjuk a verem túlcsordulásának kivételét, ahol a funkció többször is felhívja magát. Az első programhoz viszonyítva csak a kiemelt rész módosul.
Ugyanígy állíthatjuk elő a számot felhasználói beírt értékként, az alábbiak szerint:
Kód:
using System;
class First (
static void Main() (
int result, c;
string a;
Console.Write("Enter value for number :");
a = Console.ReadLine();
c = Convert.ToInt32(a);
result = fact(c);
Console.WriteLine("Factorial is : " + result);
)
public static int fact(int num)
(
if(num==0)
(
return 1;
)
return num*fact(num-1);
)
)
Kimenet:
Mi van, ha nullát adunk bemenetként? Igen, az egyiket visszatérnék.
Kimenet:
Mi van, ha negatív számot adunk?
Kimenet:
Ez egy Stack túlcsordulási kivételt is adott nekem, mivel a faktorszámú rekurziós függvényünk minden végrehajtáskor csökkenti a paraméter értékét. Tehát a negatív számok -6, -7, -8-ra csökkennek és így tovább. Ez az oka annak, hogy ebbe a kivételbe megyünk.
Gyakorlatként megpróbálhat egy negatív számok rekurzív függvényét létrehozni?
Tipp: Nullánál kisebb számú előfeltételt vehetünk fel, és add hozzá egy rekurzív függvény-paraméterünkhöz, amíg nulla meg nem jelenik.
Példák a C # rekurzív funkcióra
Kevés jó példát lehet idézni a rekurzív függvényekre vonatkozóan:
Van néhány más hely, ahol ezeket a rekurzív funkciókat használhatjuk.
- Folyamatosan nyomtasson számokat egy adott kezdőpontból és végpontból. (Program alább)
- Adjon hozzá számokat egy adott kezdőponttól kezdve és álljon meg a végpontnál, vagy amikor egy adott összeg eléri.
- Számok kinyomtatása, amelyek oszthatók bármely adott számmal, egy adott tartományban.
- Ki akarjuk nyomtatni a folytonos vonalak vagy pontok bármelyikét egy mondat megírása után és még sok más.
Mint láthatja, a rekurzív funkció hasonló a hurok funkcionalitásához, de ahol ugyanazt a funkciót ismételten hívjuk.
Nézzük meg, hogyan lehet egy rekurzív függvényt írni a számok folyamatos hozzáadásával, amíg a program meg nem találja a második számot, amelyet bemenetként adunk meg.
Kód:
using System;
class First (
static void Main() (
int result, c, d;
string a, b;
Console.Write("Enter value for 1st number :");
a = Console.ReadLine();
c = Convert.ToInt32(a);
Console.Write("Enter value for 2nd number :");
b = Console.ReadLine();
d = Convert.ToInt32(b);
result = add(c, d);
Console.WriteLine("Add is : " + result);
)
public static int add(int num1, int num2)
(
int sum ;
sum=num1;
if (num1 < num2 )
(
num1++;
sum=sum+add(num1, num2);
return sum;
)
return sum;
)
)
Itt mit tettünk:
- Két felhasználói számot, a num1 és a num2-et vettünk a felhasználói bemenetek segítségével
- Add funkcióval hozzáadja a num1-től kezdődő számokat, amíg meg nem kapja a num2-t.
Például, ha a num1 = 5 és a num2 = 8-at veszem, akkor a kapott kimeneti összeg 5 + 6 + 7 + 8, ami 26.
Kimenet:
És mi van, ha num1-nél kevesebbet adok, mint num2-t?
Kimenet:
Előbb számot ad, mint num1 értéket, az összeg értékét a num1 értékhez és a visszatérő összeget rendeljük, ha az if állítás nem alkalmazható.
Gyakorlatként megírhat egy rekurzív függvényt az “Szeretem a kódolást” kinyomtatásáig, amíg egy bizonyos feltételnek megfelel?
Tipp: Ugyanazt a hozzáadási eljárást követhetjük el, mint a fenti programban.
Következtetés
Tehát itt sikerült megszereznünk a rekurzív függvények végrehajtását, hogyan hívjuk ezeket a funkciókat, és mutatunk be néhány példát. Megtudtuk azt is, hogyan lehet egy funkció meghívásában levő egyszerű különbség miatt a program kifutni a határaitól és kivételt képezni.
Ajánlott cikkek
Ez egy útmutató a C # rekurzív funkcióhoz. Itt a példákkal tárgyaljuk a rekurzív függvény előállításának végrehajtását. Megnézheti más kapcsolódó cikkeinket, hogy többet megtudjon-
- Anonim funkciók a Matlab-ban
- Tableau karakterlánc-funkciók
- Mi a funkcionális tesztelés?
- C # Funkciók
- Bevezetés a C ++ rekurzív funkcióba
- Tanulja meg a Java felhasználói bevitel 3 olvasási módját