Introduktion till rekursiv funktion i C #
I rekursiv funktion i C # betyder rekursion samma betydelse som på det engelska språket, precis känt som att upprepa sig själv. Så, den rekursiva karaktären av en funktion anger att man gör samma arbete upprepade gånger. Och ja, om programmet inte hanteras korrekt skulle det definitivt köra programmet i en kontinuerlig slinga. Vi måste se till att vi anger lämpliga villkor för att utföra dessa rekursiva funktioner, annars skulle funktionen kalla sig själv, om och om igen, vilket leder till en kontinuerlig körning av programmet. Låt oss gå vidare och titta på hur vi kan skapa dessa funktioner i C #.
Syntax av rekursiva funktioner i C #
Syntaxen här är densamma som grundfunktionssyntaxen i C #. Låt oss ta en titt här.
Det finns ingen speciell syntax här, men vi kan observera att en funktion kallar sig själv för att ge returresultatet. Och vi måste vara mycket försiktiga när vi överför dessa parametervärden till den rekursiva funktionen eftersom vi uppenbarligen inte vill ha en körkod som inte stoppar.
I ovanstående syntax finns det inget liknande, vi måste ringa funktionen endast i uttalanden. Snarare kan vi till och med tilldela det rekursiva funktionens returvärde till en variabel och också returnera den variabeln.
Utförande av faktorisering
Låt oss här ta vårt standardproblem, Factorization, för att generera vår rekursiva funktion.
Koda:
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);
)
)
Låt oss titta på steg för steg-processen.
- Först har vi skapat vår egen parametriserade funktion för att ta ett inmatningsvärde från huvudfunktionen, för vilken vi vill beräkna factorial.
- Sedan gjorde vi ett if-villkor för att kontrollera om det givna numret är noll. Om numret är noll returnerar vi 1 som vårt standardvärde.
- Annars multiplicerar vi det nuvarande numret med den funktion som tar antalet minus 1 som dess parameter.
- Så, denna multiplikation upprepar sig tills vi kommer till nummer 0. Som standard har vi skrivit vår returutgång för noll som 1, det slutliga resultatet skulle multipliceras med 1.
Produktion:
Nu, i koden, kommer jag att ersätta vår funktionsparameter från num minus 1 till, num. I det här fallet kommer funktionen att ringa sig igen och igen och processen skulle upprepa.
Koda:
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);
)
)
Produktion:
Genom ovanstående utgång kan vi tydligt se stacköversvämningsundantaget, där funktionen upprepade gånger ringer sig. Endast den markerade delen ändras med avseende på det första programmet.
På samma sätt kan vi ange numret som ett användarinmatat värde som nedan:
Koda:
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);
)
)
Produktion:
Tänk om vi ger noll som ingång? Ja, en skulle återlämnas.
Produktion:
Vad händer nu om vi ger ett negativt tal?
Produktion:
Detta gav mig ett undantag från Stack overflow också, eftersom vår faktorella rekursionsfunktion minskar parameterns värde vid varje utförande. Så skulle de negativa siffrorna fortsätta att reduceras till -6, -7, -8 och så vidare. Det är anledningen till att vi går till detta undantag.
Kan du som en övning prova att skapa en rekursiv funktion för negativa siffror?
Tips: Vi kan ta en förutsättning för nummer mindre än noll och lägga till en till vår rekursiva funktionsparameter tills noll kommer.
Exempel på rekursiv funktion i C #
Det finns få bra exempel som kan citeras med avseende på de rekursiva funktionerna:
Vi har några andra platser där vi kan använda dessa rekursiva funktioner.
- Skriv ut siffror från en given startpunkt och slutpunkt kontinuerligt. (Program nedan)
- Lägg till siffror som börjar från en given startpunkt och stopp vid slutpunkten eller när en viss summa uppnås.
- Skriv ut nummer som är dividerade med ett visst nummer i ett visst intervall.
- Vi vill skriva ut något av antalet kontinuerliga rader eller prickar efter att vi har skrivit en mening och många fler.
Som du kan observera rekursiv funktion liknar funktionaliteten i en slinga, men där vi kallar samma funktion upprepade gånger.
Låt oss se hur vi kan skriva en rekursiv funktion genom att lägga till nummer kontinuerligt tills programmet hittar det andra numret som ges som input.
Koda:
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;
)
)
Vad vi gjorde här är:
- Vi har tagit två siffror num1 och num2 genom användaringångar
- Lägg till funktion, lägger till siffrorna som börjar från num1 tills den får num2.
Om jag till exempel tar num1 = 5 och num2 = 8, så är utgångssumman vi får 5 + 6 + 7 + 8, vilket är 26.
Produktion:
Och vad händer om jag ger num1 mindre än num2?
Produktion:
Det ger vissa som num1-värdet som första, vi tilldelade summan värdet till num1-värdet och returnerar summan om if-påståendet inte är tillämpligt.
Som en övning kan du skriva en rekursiv funktion för att skriva ut "I like coding" tills den följer ett visst villkor?
Tips: Vi kan följa samma procedur för att lägga till vilket görs i ovanstående program.
Slutsats
Så här har vi framgångsrikt genomfört rekursiva funktioner, hur dessa funktioner kallas och några exempel på dem. Vi lärde oss också hur en enkel skillnad i samtalet av en funktion kan göra att programmet tar slut och skapar ett undantag.
Rekommenderade artiklar
Detta är en guide till rekursiv funktion i C #. Här diskuterar vi exekveringen för att generera rekursiv funktion med dess exempel. Du kan också gå igenom våra andra relaterade artiklar för att lära dig mer-
- Anonyma funktioner i Matlab
- Tableau-strängfunktioner
- Vad är funktionell testning?
- C # funktioner
- Introduktion till rekursiv funktion i C ++
- Lär dig de tre sätten att läsa Java User Input