జావాలో రికర్షన్‌పై ఈ లోతైన ట్యుటోరియల్ ఉదాహరణలు, రకాలు మరియు సంబంధిత కాన్సెప్ట్‌లతో రికర్షన్ అంటే ఏమిటో వివరిస్తుంది. ఇది పునరావృతం Vs పునరుక్తిని కూడా కవర్ చేస్తుంది:
జావాలోని మా మునుపటి ట్యుటోరియల్‌ల నుండి, మేము ఒక లూప్‌ని ప్రకటించి, ఆపై ఒక మూలకాన్ని తీసుకోవడం ద్వారా డేటా స్ట్రక్చర్ ద్వారా పునరుక్తి పద్ధతిలో ప్రయాణించే పునరుక్తి విధానాన్ని చూశాము. ఒక సమయం.
మేము షరతులతో కూడిన ప్రవాహాన్ని కూడా చూశాము, ఇక్కడ మనం మళ్ళీ ఒక లూప్ వేరియబుల్‌ని ఉంచుతాము మరియు లూప్ వేరియబుల్ షరతును కలిసే వరకు కోడ్ యొక్క భాగాన్ని పునరావృతం చేస్తాము. ఫంక్షన్ కాల్‌ల విషయానికి వస్తే, మేము ఫంక్షన్ కాల్‌ల కోసం పునరావృత విధానాన్ని కూడా అన్వేషించాము.
జావాలో రికర్షన్ అంటే ఏమిటి?
పునరావృతం అనేది ఒక ఫంక్షన్ లేదా మెథడ్ తనను తాను మళ్లీ మళ్లీ పిలిచే ప్రక్రియ. ప్రత్యక్షంగా లేదా పరోక్షంగా మళ్లీ మళ్లీ పిలిచే ఈ ఫంక్షన్‌ను “రికర్సివ్ ఫంక్షన్” అంటారు.
పునరావృతాన్ని అర్థం చేసుకోవడానికి మేము వివిధ ఉదాహరణలను చూస్తాము. ఇప్పుడు పునరావృతం యొక్క వాక్యనిర్మాణాన్ని చూద్దాం.
రికర్షన్ సింటాక్స్
రికర్షన్‌ని అమలు చేసే ఏదైనా పద్ధతి రెండు ప్రాథమిక భాగాలను కలిగి ఉంటుంది:
- మెథడ్ కాల్ అంటే రికర్సివ్ అని పిలవగలిగేది
- పునరావృతాన్ని ఆపే ముందస్తు షరతు.
మనం చేయకపోతే, ఏదైనా పునరావృత పద్ధతికి ముందస్తు షరతు అవసరమని గమనించండి. విచ్ఛిన్నంపునరావృతం అప్పుడు అది అనంతంగా రన్ అవుతూనే ఉంటుంది మరియు స్టాక్ ఓవర్‌ఫ్లో ఏర్పడుతుంది.
పునరావృతం యొక్క సాధారణ వాక్యనిర్మాణం క్రింది విధంగా ఉంటుంది:
methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call } ముందస్తు షరతు కూడా పిలువబడుతుందని గమనించండి బేస్ పరిస్థితి. మేము తదుపరి విభాగంలో బేస్ కండిషన్ గురించి మరింత చర్చిస్తాము.
జావాలో రికర్షన్‌ను అర్థం చేసుకోవడం
ఈ విభాగంలో, మేము పునరావృత ప్రక్రియను అర్థం చేసుకోవడానికి ప్రయత్నిస్తాము మరియు అది ఎలా జరుగుతుందో చూద్దాం. మేము బేస్ కండిషన్, స్టాక్ ఓవర్‌ఫ్లో గురించి నేర్చుకుంటాము మరియు రికర్షన్ మరియు ఇతర వివరాలతో నిర్దిష్ట సమస్యను ఎలా పరిష్కరించవచ్చో చూద్దాం.
రికర్షన్ బేస్ కండిషన్
పునరావృత ప్రోగ్రామ్‌ను వ్రాసేటప్పుడు, మనం తప్పక మొదట బేస్ కేసుకు పరిష్కారాన్ని అందించండి. అప్పుడు మేము పెద్ద సమస్యను చిన్న సమస్యల పరంగా వ్యక్తపరుస్తాము.
ఒక ఉదాహరణగా, మేము సంఖ్య యొక్క కారకాన్ని లెక్కించే ఒక క్లాసిక్ సమస్యను తీసుకోవచ్చు. n సంఖ్యను అందించినట్లయితే, n ద్వారా సూచించబడే n యొక్క గుణకారాన్ని మనం కనుగొనవలసి ఉంటుంది!
ఇప్పుడు పునరావృత్తిని ఉపయోగించి n కారకాన్ని (n!) లెక్కించడానికి ప్రోగ్రామ్‌ను అమలు చేద్దాం.
public class Main{ static int fact(int n) { if (n == 1) // base condition return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }అవుట్‌పుట్
ఈ ప్రోగ్రామ్‌లో, కండిషన్ (n=1) బేస్ కండిషన్ అని మనం చూడవచ్చు మరియు ఈ స్థితికి చేరుకున్నప్పుడు, ఫంక్షన్ 1ని అందిస్తుంది ఫంక్షన్ యొక్క ఇతర భాగం రికర్సివ్ కాల్. కానీ పునరావృత పద్ధతిని పిలిచిన ప్రతిసారీ, n 1 ద్వారా తగ్గుతుంది.
అందువలన, n యొక్క విలువ 1 కంటే తక్కువగా లేదా 1 కంటే తక్కువగా ఉంటుందని మేము నిర్ధారించవచ్చు.పాయింట్, పద్ధతి విలువ 1ని అందిస్తుంది. ఈ బేస్ కండిషన్ చేరుకుంటుంది మరియు ఫంక్షన్ ఆగిపోతుంది. n యొక్క విలువ ఆధార స్థితిని సంతృప్తిపరిచేంత వరకు ఏదైనా కావచ్చునని గమనించండి.
సమస్య-పరిష్కారం పునరావృతాన్ని ఉపయోగించడం
పునరావృతాన్ని ఉపయోగించడం వెనుక ఉన్న ప్రాథమిక ఆలోచన ఏమిటంటే, పరంగా పెద్ద సమస్యను వ్యక్తీకరించడం చిన్న సమస్యలు. అలాగే, మేము ఒకటి లేదా అంతకంటే ఎక్కువ బేస్ షరతులను జోడించాలి, తద్వారా మనం పునరావృతం నుండి బయటపడవచ్చు.
ఇది ఇప్పటికే పై కారకం ఉదాహరణలో ప్రదర్శించబడింది. ఈ ప్రోగ్రామ్‌లో, మేము n ఫాక్టోరియల్ (n!)ని చిన్న విలువల పరంగా వ్యక్తీకరించాము మరియు బేస్ కండిషన్ (n =1)ని కలిగి ఉన్నాము, తద్వారా n 1కి చేరుకున్నప్పుడు, మేము పునరావృత పద్ధతి నుండి నిష్క్రమించవచ్చు.
రికర్షన్‌లో స్టాక్ ఓవర్‌ఫ్లో ఎర్రర్
ఏదైనా పద్ధతి లేదా ఫంక్షన్‌ని పిలిచినప్పుడు, ఫంక్షన్ యొక్క స్థితి స్టాక్‌లో నిల్వ చేయబడుతుందని మరియు ఫంక్షన్ తిరిగి వచ్చినప్పుడు తిరిగి పొందబడుతుందని మాకు తెలుసు. స్టాక్ రికర్సివ్ పద్ధతికి కూడా ఉపయోగించబడుతుంది.
కానీ పునరావృతం విషయంలో, మేము బేస్ కండిషన్‌ను నిర్వచించకపోతే లేదా బేస్ కండిషన్‌ను చేరుకోనప్పుడు లేదా అమలు చేయనప్పుడు సమస్య ఏర్పడవచ్చు. ఈ పరిస్థితి ఏర్పడితే, స్టాక్ ఓవర్‌ఫ్లో తలెత్తవచ్చు.
కాక్టోరియల్ సంజ్ఞామానం యొక్క దిగువ ఉదాహరణను పరిశీలిద్దాం.
ఇక్కడ మేము తప్పు బేస్ కండిషన్ ఇచ్చాము, n==100.
public class Main { static int fact(int n) { if (n == 100) // base condition resulting in stack overflow return 1; else return n*fact(n-1); } public static void main(String[] args) { int result = fact(10); System.out.println("10! = " + result); } }కాబట్టి n > 100 పద్ధతి 1ని అందిస్తుంది కానీ పునరావృతం ఆగదు. n విలువ అక్కడ ఉన్నట్లుగా నిరవధికంగా తగ్గుతూ ఉంటుందిదాన్ని ఆపడానికి వేరే పరిస్థితి లేదు. ఇది స్టాక్ ఓవర్‌ఫ్లో అయ్యే వరకు కొనసాగుతుంది.
మరో సందర్భంలో n విలువ 100. ఈ సందర్భంలో, అలాగే పద్ధతి బేస్ కండిషన్‌ను ఎప్పటికీ అమలు చేయదు మరియు స్టాక్ ఓవర్‌ఫ్లో ఫలితంగా ఉంటుంది.
జావాలో రికర్షన్ ఉదాహరణలు
ఈ విభాగంలో, మేము క్రింది ఉదాహరణలను ఉపయోగించి అమలు చేస్తాము పునరావృతం.
#1) ఫిబొనాక్సీ సిరీస్ రికర్షన్ ఉపయోగించి
ఫైబొనాక్సీ సిరీస్‌ని అందించింది,
1,1,2,3,5,8,13,21, 34,55,…
పై శ్రేణి ప్రస్తుత మూలకం మునుపటి రెండు మూలకాల మొత్తం అని చూపిస్తుంది. అలాగే, ఫైబొనాక్సీ సిరీస్‌లోని మొదటి మూలకం 1.
కాబట్టి సాధారణంగా n ప్రస్తుత సంఖ్య అయితే, అది (n-1) మరియు (n-2) మొత్తం ద్వారా ఇవ్వబడుతుంది. ప్రస్తుత మూలకం మునుపటి మూలకాల పరంగా వ్యక్తీకరించబడినందున, మేము ఈ సమస్యను పునరావృతాన్ని ఉపయోగించి వ్యక్తపరచగలము.
ఫైబొనాక్సీ సిరీస్‌ని అమలు చేయడానికి ప్రోగ్రామ్ క్రింద ఇవ్వబడింది:
public class Main { //method to calculate fibonacci series static int fibonacci(int n) { if (n = 1) { return n; } return fibonacci(n-1) + fibonacci(n-2); } public static void main(String[] args) { int number = 10; //print first 10 numbers of fibonacci series System.out.println ("Fibonacci Series: First 10 numbers:"); for (int i = 1; i = number; i++) { System.out.print(fibonacci(i) + " "); } } } అవుట్‌పుట్
#2) రికర్షన్ ఉపయోగించి ఒక సంఖ్య పాలిండ్రోమ్ కాదా అని తనిఖీ చేయండి
పాలిండ్రోమ్ అనేది మనం ఉన్నప్పుడు సమానంగా ఉండే క్రమం దానిని ఎడమ నుండి కుడికి లేదా కుడి నుండి ఎడమకు చదవండి.
సంఖ్య 121 ఇచ్చినప్పుడు, మనం దానిని ఎడమ నుండి కుడికి మరియు కుడి నుండి ఎడమకు చదివినప్పుడు, అది సమానంగా ఉన్నట్లు చూస్తాము. అందుకే సంఖ్య 121 పాలిండ్రోమ్.
మరో సంఖ్య తీసుకుందాం, 1242. మనం దానిని ఎడమ నుండి కుడికి చదివినప్పుడు అది 1242 మరియు కుడి నుండి ఎడమకు చదివినప్పుడు అది 2421 అని చదవబడుతుంది. కాబట్టి ఇది పాలిండ్రోమ్ కాదు.
మేముసంఖ్యల అంకెలను రివర్స్ చేయడం ద్వారా పాలిండ్రోమ్ ప్రోగ్రామ్‌ను అమలు చేయండి మరియు ఇచ్చిన సంఖ్యను దాని రివర్స్డ్ ప్రాతినిధ్యానికి పునరావృతంగా సరిపోల్చండి.
క్రింద ఉన్న ప్రోగ్రామ్ పాలిండ్రోమ్‌ను తనిఖీ చేయడానికి ప్రోగ్రామ్‌ను అమలు చేస్తుంది.
import java.io.*; import java.util.*; public class Main { // check if num contains only one digit public static int oneDigit(int num) { if ((num >= 0) && (num 10)) return 1; else return 0; } //palindrome utility function public static int isPalindrome_util (int num, int revNum) throws Exception { // base condition; return if num=0 if (num == 0) { return revNum; } else { //call utility function recursively revNum = isPalindrome_util(num / 10, revNum); } // Check if first digit of num and revNum are equal if (num % 10 == revNum % 10) { // if yes, revNum will move with num return revNum / 10; } else { // exit throw new Exception(); } } //method to check if a given number is palindrome using palindrome utility function public static int isPalindrome(int num) throws Exception { if (num 0) num = (-num); int revNum = (num); return isPalindrome_util(num, revNum); } public static void main(String args[]) { int n = 1242; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } n = 1221; try { isPalindrome(n); System.out.println("Yes, the given number " + n + " is a palindrome."); } catch (Exception e) { System.out.println("No, the given number " + n + " is not a palindrome."); } } }అవుట్‌పుట్
#3) రివర్స్ స్ట్రింగ్ రికర్షన్ జావా
“హలో” అనే స్ట్రింగ్ ఇచ్చినప్పుడు మనం దానిని రివర్స్ చేయాలి. ఫలిత స్ట్రింగ్ “olleH”.
ఇది రికర్షన్ ఉపయోగించి చేయబడుతుంది. స్ట్రింగ్‌లోని చివరి అక్షరం నుండి ప్రారంభించి, స్ట్రింగ్‌లోని అన్ని అక్షరాలు అయిపోయే వరకు మేము ప్రతి అక్షరాన్ని పునరావృతంగా ప్రింట్ చేస్తాము.
క్రింద ఉన్న ప్రోగ్రామ్ ఇచ్చిన స్ట్రింగ్‌ను రివర్స్ చేయడానికి రికర్షన్‌ని ఉపయోగిస్తుంది.
class String_Reverse { //recursive method to reverse a given string void reverseString(String str) { //base condition; return if string is null or with 1 or less character if ((str==null)||(str.length() = 1)) System.out.println(str); else { //recursively print each character in the string from the end System.out.print(str.charAt(str.length()-1)); reverseString(str.substring(0,str.length()-1)); } } } class Main{ public static void main(String[] args) { String inputstr = "SoftwareTestingHelp"; System.out.println("The given string: " + inputstr); String_Reverse obj = new String_Reverse(); System.out.print("The reversed string: "); obj.reverseString(inputstr); } } అవుట్‌పుట్
#4) బైనరీ సెర్చ్ జావా రికర్షన్
బైనరీ సెర్చ్ అల్గోరిథం అనేది శోధించడానికి ఒక ప్రసిద్ధ అల్గారిథమ్. ఈ అల్గారిథమ్‌లో, n మూలకాల యొక్క క్రమబద్ధీకరించబడిన శ్రేణి ఇవ్వబడింది, మేము ఈ శ్రేణిని ఇచ్చిన కీ మూలకం కోసం శోధిస్తాము. ప్రారంభంలో, మేము శ్రేణి యొక్క మధ్య మూలకాన్ని కనుగొనడం ద్వారా శ్రేణిని రెండు భాగాలుగా విభజిస్తాము.
తర్వాత కీ మిడ్‌ని బట్టి మన శోధనను శ్రేణి యొక్క మొదటి లేదా రెండవ భాగంలో పరిమితం చేస్తాము. ఈ విధంగా కీలక మూలకాల స్థానాన్ని కనుగొనే వరకు అదే ప్రక్రియ పునరావృతమవుతుంది.
మేము ఈ అల్గారిథమ్‌ని ఇక్కడ పునరావృతం ఉపయోగించి అమలు చేస్తాము.
import java.util.*; class Binary_Search { // recursive binary search int binarySearch(int numArray[], int left, int right, int key) { if (right >= left) { //calculate mid of the array int mid = left + (right - left) / 2; // if the key is at mid, return mid if (numArray[mid] == key) return mid; // if key key) return binarySearch(numArray, left, mid - 1, key); // Else recursively search in the right subarray return binarySearch(numArray, mid + 1, right, key); } // no elements in the array, return -1 return -1; } } class Main{ public static void main(String args[]) { Binary_Search ob = new Binary_Search(); //declare and print the array int numArray[] = { 4,6,12,16,22}; System.out.println("The given array : " + Arrays.toString(numArray)); int len = numArray.length; //length of the array int key = 16; //key to be searched int result = ob.binarySearch(numArray, 0, len - 1, key); if (result == -1) System.out.println("Element " + key + " not present"); else System.out.println("Element " + key + " found at index " + result); } } అవుట్‌పుట్
#5) రికర్షన్‌ని ఉపయోగించి అర్రేలో కనిష్ట విలువను కనుగొనండి
రికర్షన్‌ని ఉపయోగించి మనం అర్రేలో కనీస విలువను కూడా కనుగొనవచ్చు.
దిశ్రేణిలో కనీస విలువను కనుగొనడానికి జావా ప్రోగ్రామ్ క్రింద ఇవ్వబడింది.
import java.util.*; class Main { static int getMin(int numArray[], int i, int n) { //return first element if only one element or minimum of the array elements return (n == 1) ? numArray[i] : Math.min(numArray[i], getMin(numArray,i + 1 , n - 1)); } public static void main(String[] args) { int numArray[] = { 7,32,64,2,10,23 }; System.out.println("Given Array : " + Arrays.toString(numArray)); int n = numArray.length; System.out.print("Minimum element of array: " + getMin(numArray, 0, n) + "\n"); } }అవుట్‌పుట్
ఇవి కొన్ని పునరావృతం యొక్క ఉదాహరణలు. ఈ ఉదాహరణలే కాకుండా, సాఫ్ట్‌వేర్‌లోని అనేక ఇతర సమస్యలను పునరావృత సాంకేతికతలను ఉపయోగించి అమలు చేయవచ్చు.
పునరావృత రకాలు
పునరావృతానికి కాల్ చేసినప్పుడు దాని ఆధారంగా రెండు రకాలుగా ఉంటాయి. పునరావృత పద్ధతి పునరావృత పద్ధతిలో అమలు చేయబడుతుంది, దీనిని "టెయిల్ రికర్షన్" అంటారు.
టెయిల్ రికర్షన్‌లో, రికర్సివ్ కాల్ స్టేట్‌మెంట్ సాధారణంగా పద్ధతి యొక్క రిటర్న్ స్టేట్‌మెంట్‌తో పాటు అమలు చేయబడుతుంది.
టెయిల్ రికర్షన్ కోసం సాధారణ సింటాక్స్ క్రింద ఇవ్వబడింది:
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion } #2) హెడ్ రికర్షన్
హెడ్ రికర్షన్ అనేది టెయిల్ రికర్షన్ కాని ఏదైనా రికర్సివ్ విధానం. కాబట్టి సాధారణ రికర్షన్ కూడా రికర్షన్ కంటే ముందు ఉంటుంది.
హెడ్ రికర్షన్ యొక్క సింటాక్స్ క్రింది విధంగా ఉంది:
methodName (T parameters…){ if (some_condition == true) { return methodName (T parameters…); } return result; } జావాలో పునరావృతం Vs పునరావృతం
| పునరావృతం | |
|---|---|
| పునరావృతం అనేది ఒక పద్ధతి, ఆధార స్థితిని పొందే వరకు పదే పదే కాల్ చేసే ప్రక్రియ. | పునరావృతం పరిమిత సంఖ్యలో లేదా షరతు నెరవేరే వరకు కోడ్ ముక్క పదేపదే అమలు చేయబడే ప్రక్రియ. |
| ఫంక్షన్‌ల కోసం అప్లికేషన్. | వర్తించవచ్చు లూప్‌ల కోసం. |
| దీనికి బాగా పని చేస్తుందిచిన్న కోడ్ పరిమాణం. | పెద్ద కోడ్ పరిమాణానికి బాగా పని చేస్తుంది. |
| ప్రతి పునరావృత కాల్ స్టాక్‌కి నెట్టబడినందున ఎక్కువ మెమరీని వినియోగిస్తుంది | సాపేక్షంగా తక్కువ మెమరీ ఉపయోగించబడుతుంది. |
| డీబగ్ చేయడం మరియు నిర్వహించడం కష్టం | డీబగ్ చేయడం మరియు నిర్వహించడం సులభం |
| ఆధారం అయితే స్టాక్ ఓవర్‌ఫ్లో ఫలితాలు పరిస్థితి పేర్కొనబడలేదు లేదా చేరుకోలేదు. | అనంతంగా అమలు చేయవచ్చు కానీ ఏదైనా మెమరీ లోపాలతో చివరికి అమలును ఆపివేస్తుంది |
| సమయ సంక్లిష్టత చాలా ఎక్కువగా ఉంది. | సమయ సంక్లిష్టత సాపేక్షంగా దిగువ భాగంలో ఉంది. |
తరచుగా అడిగే ప్రశ్నలు
Q #1) జావాలో రికర్షన్ ఎలా పని చేస్తుంది?
సమాధానం: రికర్షన్‌లో, బేస్ కండిషన్ సంతృప్తి చెందే వరకు రికర్సివ్ ఫంక్షన్ పదే పదే కాల్ చేస్తుంది. కాల్ ఫంక్షన్ కోసం మెమరీ కాలింగ్ ఫంక్షన్ కోసం మెమరీ ఎగువన ఉన్న స్టాక్‌కు నెట్టబడుతుంది. ప్రతి ఫంక్షన్ కాల్ కోసం, లోకల్ వేరియబుల్స్ యొక్క ప్రత్యేక కాపీ తయారు చేయబడింది.
Q #2) రికర్షన్ ఎందుకు ఉపయోగించబడుతుంది?
సమాధానం: రికర్షన్ అనేది చిన్న సమస్యలుగా విభజించబడే సమస్యలను పరిష్కరించడానికి ఉపయోగించబడుతుంది మరియు మొత్తం సమస్యను చిన్న సమస్యగా వ్యక్తీకరించవచ్చు.
అత్యంత సమస్యలకు కూడా పునరావృత్తి ఉపయోగించబడుతుంది. పునరావృత విధానాన్ని ఉపయోగించి పరిష్కరించాల్సిన సంక్లిష్టమైనది. సమయ సంక్లిష్టత సమస్య లేని సమస్యలతో పాటు, రికర్షన్‌ని ఉపయోగించండి.
Q #3) దీని వల్ల కలిగే ప్రయోజనాలు ఏమిటిపునరావృతమా?
సమాధానం:
పునరావృతం యొక్క ప్రయోజనాలు:
- పునరావృతం అనవసరమైన కాలింగ్‌ని తగ్గిస్తుంది ఫంక్షన్ యొక్క.
- పునరావృత విధానంతో పోల్చినప్పుడు రికర్షన్ సమస్యలను సులభంగా పరిష్కరించేందుకు అనుమతిస్తుంది.
Q #4) ఏది ఉత్తమం – పునరావృతం లేదా పునరావృతం?
సమాధానం: ఆధార ఫంక్షన్ చేరుకునే వరకు రికర్షన్ పదే పదే కాల్‌లు చేస్తుంది. ఈ విధంగా ప్రతి ఫంక్షన్ కాల్‌కు మెమరీని స్టాక్‌పైకి నెట్టడం వలన మెమరీ ఓవర్‌హెడ్ ఉంటుంది.
మరోవైపు పునరావృతం ఎక్కువ మెమరీ ఓవర్‌హెడ్‌ను కలిగి ఉండదు. పునరావృత విధానం కంటే పునరావృత అమలు నెమ్మదిగా ఉంటుంది. పునరావృత విధానం కోడ్ యొక్క పరిమాణాన్ని తగ్గిస్తుంది, అయితే పునరావృత విధానం కోడ్‌ను పెద్దదిగా చేస్తుంది.
Q #5) మళ్లీ పునరావృతం చేయడం వల్ల కలిగే ప్రయోజనాలు ఏమిటి?
సమాధానం:
- రికర్షన్ కోడ్‌ను స్పష్టంగా మరియు చిన్నదిగా చేస్తుంది.
- టవర్ ఆఫ్ హనోయి, చెట్టు వంటి సమస్యలకు పునరావృత విధానం కంటే పునరావృతం ఉత్తమం ట్రావర్సల్స్ మొదలైనవి.
- ప్రతి ఫంక్షన్ కాల్ మెమరీని స్టాక్‌పైకి నెట్టివేయబడినందున, రికర్షన్ ఎక్కువ మెమరీని ఉపయోగిస్తుంది.
- పునరావృత విధానం కంటే పునరావృత పనితీరు నెమ్మదిగా ఉంటుంది.
ముగింపు
ప్రోగ్రామింగ్ లాంగ్వేజ్‌తో సంబంధం లేకుండా సాఫ్ట్‌వేర్‌లో పునరావృతం అనేది చాలా ముఖ్యమైన అంశం. హనోయి యొక్క టవర్లు, ట్రీ ట్రావర్సల్స్, లింక్డ్ లిస్ట్‌లు మొదలైన డేటా నిర్మాణ సమస్యలను పరిష్కరించడంలో రికర్షన్ ఎక్కువగా ఉపయోగించబడుతుంది. దీనికి ఎక్కువ మెమరీ అవసరం అయినప్పటికీ,పునరావృతం కోడ్‌ని సులభతరం చేస్తుంది మరియు స్పష్టంగా చేస్తుంది.
మేము ఈ ట్యుటోరియల్‌లో రికర్షన్ గురించి అన్నింటినీ అన్వేషించాము. కాన్సెప్ట్‌ను బాగా అర్థం చేసుకోవడానికి మేము అనేక ప్రోగ్రామింగ్ ఉదాహరణలను కూడా అమలు చేసాము.