ജാവയിലെ ആവർത്തനത്തെക്കുറിച്ചുള്ള ഈ ആഴത്തിലുള്ള ട്യൂട്ടോറിയൽ, ഉദാഹരണങ്ങൾ, തരങ്ങൾ, അനുബന്ധ ആശയങ്ങൾ എന്നിവ ഉപയോഗിച്ച് റിക്കർഷൻ എന്താണെന്ന് വിശദീകരിക്കുന്നു. ഇത് ആവർത്തനവും ആവർത്തനവും ഉൾക്കൊള്ളുന്നു:
ജാവയിലെ ഞങ്ങളുടെ മുമ്പത്തെ ട്യൂട്ടോറിയലുകളിൽ നിന്ന്, ഞങ്ങൾ ഒരു ലൂപ്പ് പ്രഖ്യാപിക്കുകയും ഒരു ഡാറ്റാ ഘടനയിലൂടെ ഒരു ഘടകം എടുത്ത് ആവർത്തന രീതിയിൽ സഞ്ചരിക്കുകയും ചെയ്യുന്ന ആവർത്തന സമീപനം ഞങ്ങൾ കണ്ടു. ഒരു സമയം.
ഞങ്ങൾ വീണ്ടും ഒരു ലൂപ്പ് വേരിയബിൾ നിലനിർത്തുകയും ലൂപ്പ് വേരിയബിൾ വ്യവസ്ഥ പാലിക്കുന്നത് വരെ ഒരു കോഡ് ആവർത്തിക്കുകയും ചെയ്യുന്ന സോപാധികമായ ഒഴുക്കും ഞങ്ങൾ കണ്ടു. ഫംഗ്‌ഷൻ കോളുകളുടെ കാര്യം വരുമ്പോൾ, ഫംഗ്‌ഷൻ കോളുകൾക്കായുള്ള ആവർത്തന സമീപനവും ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്തു> ഈ ട്യൂട്ടോറിയലിൽ, പ്രോഗ്രാമിംഗിലേക്കുള്ള മറ്റൊരു സമീപനം, അതായത് ആവർത്തന സമീപനം ഞങ്ങൾ ചർച്ച ചെയ്യും.
ജാവയിൽ എന്താണ് ആവർത്തനം?
ഒരു ഫംഗ്‌ഷൻ അല്ലെങ്കിൽ ഒരു രീതി സ്വയം വീണ്ടും വീണ്ടും വിളിക്കുന്ന ഒരു പ്രക്രിയയാണ് ആവർത്തനം. നേരിട്ടോ അല്ലാതെയോ വീണ്ടും വീണ്ടും വിളിക്കപ്പെടുന്ന ഈ ഫംഗ്‌ഷൻ "ആവർത്തന പ്രവർത്തനം" എന്ന് വിളിക്കുന്നു.
ആവർത്തനത്തെ മനസ്സിലാക്കാൻ നമുക്ക് വിവിധ ഉദാഹരണങ്ങൾ കാണാം. ഇനി നമുക്ക് ആവർത്തനത്തിന്റെ വാക്യഘടന നോക്കാം.
Recursion Syntax
Recursion നടപ്പിലാക്കുന്ന ഏതൊരു രീതിക്കും രണ്ട് അടിസ്ഥാന ഭാഗങ്ങളുണ്ട്:
- സ്വയം വിളിക്കാൻ കഴിയുന്ന മെത്തേഡ് കോൾ, അതായത് ആവർത്തനാത്മകം
- ആവർത്തനത്തെ തടയുന്ന ഒരു മുൻവ്യവസ്ഥ.
നമ്മൾ അങ്ങനെ ചെയ്യുന്നില്ലെങ്കിൽ, ഏതൊരു ആവർത്തന രീതിക്കും ഒരു മുൻവ്യവസ്ഥ ആവശ്യമാണെന്ന കാര്യം ശ്രദ്ധിക്കുക. തകർക്കുകആവർത്തനം പിന്നീട് അത് അനന്തമായി പ്രവർത്തിക്കുകയും ഒരു സ്റ്റാക്ക് ഓവർഫ്ലോയിൽ കലാശിക്കുകയും ചെയ്യും.
ആവർത്തനത്തിന്റെ പൊതുവായ വാക്യഘടന ഇപ്രകാരമാണ്:
methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call } പ്രീകണ്ടീഷനെയും വിളിക്കുന്നത് ശ്രദ്ധിക്കുക അടിസ്ഥാന അവസ്ഥ. അടിസ്ഥാന അവസ്ഥയെക്കുറിച്ച് അടുത്ത വിഭാഗത്തിൽ നമ്മൾ കൂടുതൽ ചർച്ച ചെയ്യും.
Java-ലെ ആവർത്തനത്തെ മനസ്സിലാക്കുന്നു
ഈ വിഭാഗത്തിൽ, ആവർത്തന പ്രക്രിയ മനസ്സിലാക്കാനും അത് എങ്ങനെ സംഭവിക്കുന്നുവെന്ന് കാണാനും ഞങ്ങൾ ശ്രമിക്കും. അടിസ്ഥാന അവസ്ഥയെക്കുറിച്ചും സ്റ്റാക്ക് ഓവർഫ്ലോയെക്കുറിച്ചും ഞങ്ങൾ പഠിക്കും, കൂടാതെ ആവർത്തനവും മറ്റ് വിശദാംശങ്ങളും ഉപയോഗിച്ച് ഒരു പ്രത്യേക പ്രശ്നം എങ്ങനെ പരിഹരിക്കാമെന്ന് നോക്കാം.
ആവർത്തന ബേസ് അവസ്ഥ
ആവർത്തന പ്രോഗ്രാം എഴുതുമ്പോൾ, നമ്മൾ ചെയ്യേണ്ടത് ആദ്യം അടിസ്ഥാന കേസിനുള്ള പരിഹാരം നൽകുക. തുടർന്ന് ചെറിയ പ്രശ്‌നങ്ങളുടെ അടിസ്ഥാനത്തിൽ ഞങ്ങൾ വലിയ പ്രശ്നം പ്രകടിപ്പിക്കുന്നു.
ഒരു ഉദാഹരണമായി, ഒരു സംഖ്യയുടെ ഫാക്‌ടോറിയൽ കണക്കാക്കുന്നതിനുള്ള ഒരു ക്ലാസിക് പ്രശ്നം നമുക്ക് എടുക്കാം. 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; } Recursion Vs Iteration in Java
| ആവർത്തനം | ആവർത്തനം |
|---|---|
| ഒരു അടിസ്ഥാന വ്യവസ്ഥ പാലിക്കുന്നത് വരെ ഒരു രീതി സ്വയം ആവർത്തിച്ച് വിളിക്കുന്ന ഒരു പ്രക്രിയയാണ് ആവർത്തനം. | ആവർത്തനമാണ് ഒരു കോഡ് ഒരു നിശ്ചിത എണ്ണം പ്രാവശ്യം അല്ലെങ്കിൽ ഒരു നിബന്ധന പാലിക്കുന്നത് വരെ ആവർത്തിച്ച് നടപ്പിലാക്കുന്ന ഒരു പ്രക്രിയ. |
| ഫംഗ്ഷനുകൾക്കായുള്ള അപേക്ഷയാണ്. | ബാധകമാണ് ലൂപ്പുകൾക്കായി. |
| നന്നായി പ്രവർത്തിക്കുന്നുചെറിയ കോഡ് വലുപ്പം. | വലിയ കോഡ് വലുപ്പത്തിന് നന്നായി പ്രവർത്തിക്കുന്നു. |
| ഓരോ ആവർത്തന കോളും സ്റ്റാക്കിലേക്ക് തള്ളുമ്പോൾ കൂടുതൽ മെമ്മറി ഉപയോഗപ്പെടുത്തുന്നു | താരതമ്യേന കുറവ് മെമ്മറി ഉപയോഗിക്കുന്നു. |
| ഡീബഗ് ചെയ്യാനും പരിപാലിക്കാനും ബുദ്ധിമുട്ടാണ് | ഡീബഗ് ചെയ്യാനും പരിപാലിക്കാനും എളുപ്പമാണ് |
| അടിസ്ഥാനമാണെങ്കിൽ സ്റ്റാക്ക് ഓവർഫ്ലോയിൽ ഫലങ്ങൾ വ്യവസ്ഥ വ്യക്തമാക്കിയിട്ടില്ല അല്ലെങ്കിൽ എത്തിയിട്ടില്ല. | അനന്തമായി എക്സിക്യൂട്ട് ചെയ്‌തേക്കാം, എന്നാൽ ഏതെങ്കിലും മെമ്മറി പിശകുകൾ ഉപയോഗിച്ച് ആത്യന്തികമായി എക്സിക്യൂഷൻ നിർത്തും |
| സമയ സങ്കീർണ്ണത വളരെ ഉയർന്നതാണ്. | സമയ സങ്കീർണ്ണത താരതമ്യേന താഴ്ന്ന ഭാഗത്താണ്. |
പതിവായി ചോദിക്കുന്ന ചോദ്യങ്ങൾ
Q #1) ജാവയിൽ റികർഷൻ എങ്ങനെ പ്രവർത്തിക്കുന്നു?
ഉത്തരം: ആവർത്തനത്തിൽ, ഒരു അടിസ്ഥാന വ്യവസ്ഥ തൃപ്‌തികരമാകുന്നത് വരെ ആവർത്തന ഫംഗ്‌ഷൻ തന്നെ ആവർത്തിച്ച് വിളിക്കുന്നു. കോളിംഗ് ഫംഗ്‌ഷന്റെ മെമ്മറിയുടെ മുകളിലുള്ള സ്റ്റാക്കിലേക്ക് വിളിക്കപ്പെടുന്ന ഫംഗ്‌ഷന്റെ മെമ്മറി പുഷ് ചെയ്യുന്നു. ഓരോ ഫംഗ്‌ഷൻ കോളിനും, ലോക്കൽ വേരിയബിളുകളുടെ ഒരു പ്രത്യേക പകർപ്പ് നിർമ്മിക്കപ്പെടുന്നു.
Q #2) ആവർത്തനം എന്തിനാണ് ഉപയോഗിക്കുന്നത്?
ഉത്തരം: ചെറിയ പ്രശ്‌നങ്ങളായി വിഭജിക്കാവുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കാനും മുഴുവൻ പ്രശ്‌നവും ഒരു ചെറിയ പ്രശ്‌നത്തിന്റെ അടിസ്ഥാനത്തിൽ പ്രകടിപ്പിക്കാനും കഴിയുന്ന പ്രശ്നങ്ങൾ പരിഹരിക്കാനാണ് ആവർത്തനം ഉപയോഗിക്കുന്നത്.
ആവർത്തനവും ഉപയോഗിക്കുന്നു. ഒരു ആവർത്തന സമീപനം ഉപയോഗിച്ച് പരിഹരിക്കേണ്ട സങ്കീർണ്ണത. സമയ സങ്കീർണ്ണത ഒരു പ്രശ്നമല്ലാത്ത പ്രശ്നങ്ങൾക്ക് പുറമെ, ആവർത്തനം ഉപയോഗിക്കുക.
Q #3) ഇതിന്റെ പ്രയോജനങ്ങൾ എന്തൊക്കെയാണ്ആവർത്തനമോ?
ഉത്തരം:
ആവർത്തനത്തിന്റെ നേട്ടങ്ങളിൽ ഇവ ഉൾപ്പെടുന്നു:
- ആവർത്തനം അനാവശ്യ കോളിംഗ് കുറയ്ക്കുന്നു പ്രവർത്തനത്തിന്റെ.
- ആവർത്തന സമീപനവുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ പ്രശ്നങ്ങൾ എളുപ്പത്തിൽ പരിഹരിക്കാൻ ആവർത്തനം നമ്മെ അനുവദിക്കുന്നു.
Q #4) ഏതാണ് മികച്ചത് - ആവർത്തനമോ ആവർത്തനമോ?
ഉത്തരം: ബേസ് ഫംഗ്‌ഷൻ എത്തുന്നതുവരെ ആവർത്തന കോളുകൾ ചെയ്യുന്നു. അങ്ങനെ ഓരോ ഫംഗ്‌ഷൻ കോളിനും ഒരു മെമ്മറി സ്റ്റാക്കിലേക്ക് തള്ളുന്നതിനാൽ ഒരു മെമ്മറി ഓവർഹെഡുണ്ട്.
മറുവശത്ത് ആവർത്തനത്തിന് അധിക മെമ്മറി ഇല്ല. റിക്കർഷൻ എക്സിക്യൂഷൻ ആവർത്തന സമീപനത്തേക്കാൾ മന്ദഗതിയിലാണ്. ആവർത്തന സമീപനം കോഡിനെ വലുതാക്കുമ്പോൾ ആവർത്തനം കോഡിന്റെ വലുപ്പം കുറയ്ക്കുന്നു.
Q #5) ആവർത്തനത്തേക്കാൾ ആവർത്തനത്തിന്റെ പ്രയോജനങ്ങൾ എന്തൊക്കെയാണ്?
ഉത്തരം:
- ആവർത്തനം കോഡ് കൂടുതൽ വ്യക്തവും ഹ്രസ്വവുമാക്കുന്നു.
- ഹനോയി ടവർ, ട്രീ തുടങ്ങിയ പ്രശ്‌നങ്ങൾക്കുള്ള ആവർത്തന സമീപനത്തേക്കാൾ മികച്ചതാണ് ആവർത്തനം ട്രാവേഴ്‌സലുകൾ മുതലായവ.
- ഓരോ ഫംഗ്‌ഷൻ കോളിനും മെമ്മറി സ്റ്റാക്കിലേക്ക് പുഷ് ചെയ്‌തിരിക്കുന്നതിനാൽ, റികർഷൻ കൂടുതൽ മെമ്മറി ഉപയോഗിക്കുന്നു.
- ആവർത്തന സമീപനത്തേക്കാൾ ആവർത്തന പ്രകടനം മന്ദഗതിയിലാണ്.
ഉപസംഹാരം
പ്രോഗ്രാമിംഗ് ഭാഷ പരിഗണിക്കാതെ തന്നെ സോഫ്റ്റ്വെയറിലെ വളരെ പ്രധാനപ്പെട്ട ഒരു ആശയമാണ് ആവർത്തനം. ഹനോയിയിലെ ടവറുകൾ, ട്രീ ട്രാവേർസലുകൾ, ലിങ്ക്ഡ് ലിസ്റ്റുകൾ മുതലായവ പോലുള്ള ഡാറ്റാ ഘടന പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനാണ് ആവർത്തനം കൂടുതലും ഉപയോഗിക്കുന്നത്. ഇതിന് കൂടുതൽ മെമ്മറി ആവശ്യമാണെങ്കിലും,ആവർത്തനം കോഡ് ലളിതവും വ്യക്തവുമാക്കുന്നു.
ഈ ട്യൂട്ടോറിയലിൽ ഞങ്ങൾ ആവർത്തനത്തെക്കുറിച്ച് എല്ലാം പര്യവേക്ഷണം ചെയ്തിട്ടുണ്ട്. ആശയം നന്നായി മനസ്സിലാക്കുന്നതിനായി ഞങ്ങൾ നിരവധി പ്രോഗ്രാമിംഗ് ഉദാഹരണങ്ങളും നടപ്പിലാക്കിയിട്ടുണ്ട്.