ජාවා හි පුනරාවර්තනය පිළිබඳ මෙම ගැඹුරු නිබන්ධනය උදාහරණ, වර්ග සහ අදාළ සංකල්ප සමඟින් පුනරාවර්තනය යනු කුමක්දැයි පැහැදිලි කරයි. එය පුනරාවර්තනය එදිරිව පුනරාවර්තනය ද ආවරණය කරයි:
ජාවා හි අපගේ පෙර නිබන්ධන වලින්, අපි පුනරාවර්තන ප්‍රවේශය දැක ඇති අතර එහිදී අපි ලූපයක් ප්‍රකාශ කර පසුව එක් මූලද්‍රව්‍යයක් ගෙන දත්ත ව්‍යුහයක් හරහා පුනරාවර්තන ආකාරයෙන් ගමන් කරමු. කාලයක්.
අපි නැවතත් එක් ලූප් විචල්‍යයක් තබාගෙන ලූප් විචල්‍යය කොන්දේසිය සපුරාලන තෙක් කේතයක් නැවත නැවත කරන කොන්දේසිගත ප්‍රවාහය ද අපි දැක ඇත්තෙමු. ක්‍රියාකාරී ඇමතුම් සම්බන්ධයෙන් ගත් විට, අපි ක්‍රියාකාරී ඇමතුම් සඳහා පුනරාවර්තන ප්‍රවේශය ද ගවේෂණය කළෙමු> මෙම නිබන්ධනයේදී, අපි ක්‍රමලේඛනයට වෙනස් ප්‍රවේශයක් එනම් පුනරාවර්තන ප්‍රවේශය ගැන සාකච්ඡා කරමු.
Java හි ප්‍රත්‍යාවර්තනය යනු කුමක්ද?
ප්‍රත්‍යාවර්තනය යනු ශ්‍රිතයක් හෝ ක්‍රමයක් නැවත නැවතත් තමන්වම කැඳවන ක්‍රියාවලියකි. සෘජුව හෝ වක්‍රව නැවත නැවතත් හැඳින්වෙන මෙම ශ්‍රිතය “ප්‍රත්‍යාවර්ත ශ්‍රිතය” ලෙස හැඳින්වේ.
ප්‍රතිවර්තනය තේරුම් ගැනීමට විවිධ උදාහරණ දකිමු. දැන් අපි බලමු recursion එකේ syntax එක.
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); } }Output
මෙම ක්‍රමලේඛයේ දී, කොන්දේසිය (n=1) මූලික කොන්දේසිය වන අතර, මෙම තත්ත්වයට පැමිණි විට, ශ්‍රිතය 1 නැවත ලබා දෙන බව අපට දැකගත හැක. ශ්‍රිතයේ අනෙක් කොටස වන්නේ පුනරාවර්තන ඇමතුමයි. නමුත් ප්‍රත්‍යාවර්තී ක්‍රමය හඳුන්වන සෑම අවස්ථාවකම, n 1 කින් අඩු කරනු ලැබේ.
මෙමගින් අපට නිගමනය කළ හැක්කේ අවසානයේ n හි අගය 1 හෝ 1 ට වඩා අඩු වන අතර මෙහිදීලක්ෂ්‍යය, ක්‍රමය මඟින් අගය 1 ලබා දෙනු ඇත. මෙම මූලික තත්ත්වයට ළඟා වන අතර ශ්‍රිතය නතර වනු ඇත. n හි අගය මූලික තත්ත්වය තෘප්තිමත් වන තාක් ඕනෑම දෙයක් විය හැකි බව සලකන්න.
Recursion භාවිතයෙන් ගැටළු විසඳීම
ප්‍රතිවර්තනය භාවිතා කිරීම පිටුපස ඇති මූලික අදහස වන්නේ විශාල ගැටලුව ප්‍රකාශ කිරීම කුඩා ගැටළු. එසේම, අපට පුනරාවර්තනයෙන් පිටතට පැමිණිය හැකි වන පරිදි මූලික කොන්දේසි එකක් හෝ කිහිපයක් එකතු කිරීම අවශ්‍ය වේ.
මෙය දැනටමත් ඉහත සාධක උදාහරණයෙන් පෙන්නුම් කර ඇත. මෙම වැඩසටහනේදී, අපි n සාධකමය (n!) කුඩා අගයන් අනුව ප්‍රකාශ කළ අතර පාදක කොන්දේසියක් (n =1) ඇති නිසා n 1ට ළඟා වූ විට, අපට ප්‍රත්‍යාවර්තී ක්‍රමයෙන් ඉවත් විය හැක.
Recursion තුළ Stack Overflow Error
ඕනෑම ක්‍රමයක් හෝ ශ්‍රිතයක් කැඳවූ විට, ශ්‍රිතයේ තත්ත්වය තොගයේ ගබඩා කර ඇති අතර ශ්‍රිතය නැවත පැමිණෙන විට එය ලබා ගන්නා බව අපි දනිමු. ප්‍රත්‍යාවර්තී ක්‍රමය සඳහාද stack භාවිතා වේ.
නමුත් පුනරාවර්තනයේදී, අපි මූලික තත්ත්වය නිර්වචනය නොකළහොත් හෝ මූලික තත්ත්වය කෙසේ හෝ ළඟා නොවූ විට හෝ ක්‍රියාත්මක නොකළහොත් ගැටලුවක් ඇති විය හැක. මෙම තත්ත්වය ඇති වුවහොත් තොග පිටාර ගැලීම ඇතිවිය හැක.
සාධක අංකනය පිළිබඳ පහත උදාහරණය සලකා බලමු.
මෙහි අපි වැරදි මූලික කොන්දේසියක් ලබා දී ඇත, 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. මෙම අවස්ථාවෙහිදී, ක්‍රමය කිසි විටෙක මූලික තත්ත්වය ක්‍රියාත්මක නොකරන අතර එහි ප්‍රතිඵලයක් ලෙස තොග පිටාර ගැලීමක් සිදු නොවේ.
Java හි ප්‍රත්‍යාවර්තන උදාහරණ
මෙම කොටසේදී, අපි පහත උදාහරණ භාවිතා කර ක්‍රියාත්මක කරන්නෙමු. recursion.
#1) Fibonacci Series Using Recursion
Fibonacci ශ්‍රේණිය ලබා දී ඇත්තේ,
1,1,2,3,5,8,13,21, 34,55,…
ඉහත අනුපිළිවෙලින් පෙන්නුම් කරන්නේ වත්මන් මූලද්‍රව්‍යය පෙර මූලද්‍රව්‍ය දෙකේ එකතුව බවයි. එසේම, Fibonacci ශ්‍රේණියේ පළමු මූලද්‍රව්‍යය 1 වේ.
ඉතින් සාමාන්‍යයෙන් n යනු වත්මන් සංඛ්‍යාව නම්, එය (n-1) සහ (n-2) එකතුවෙන් දෙනු ලැබේ. වත්මන් මූලද්‍රව්‍යය පෙර මූලද්‍රව්‍ය අනුව ප්‍රකාශ කර ඇති බැවින්, අපට මෙම ගැටලුව පුනරාවර්තනය භාවිතයෙන් ප්‍රකාශ කළ හැක.
Fibonacci ශ්‍රේණිය ක්‍රියාත්මක කිරීමේ වැඩසටහන පහත දැක්වේ:
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) ප්‍රත්‍යාවර්තනය භාවිතා කරමින් අංකයක් Palindrome ද යන්න පරීක්ෂා කරන්න
palindrome යනු අප විට සමාන වන අනුපිළිවෙලකි. එය වමේ සිට දකුණට හෝ දකුණේ සිට වමට කියවන්න.
අංක 121ක් ලබා දී ඇති විට, එය වමේ සිට දකුණට සහ දකුණේ සිට වමට කියවන විට එය සමාන බව අපට පෙනේ. එබැවින් අංක 121 යනු palindrome වේ.
අපි තවත් අංකයක් ගනිමු, 1242. අපි එය වමේ සිට දකුණට කියවන විට එය 1242 වන අතර දකුණේ සිට වමට කියවන විට එය 2421 ලෙස කියවේ. මේ අනුව මෙය palindrome නොවේ.
අපිසංඛ්‍යාවල ඉලක්කම් ප්‍රතිලෝම කිරීම මගින් palindrome වැඩසටහන ක්‍රියාත්මක කරන්න සහ ලබා දී ඇති සංඛ්‍යාව එහි ප්‍රතිලෝම නිරූපණයට ප්‍රත්‍යාවර්තීව සංසන්දනය කරන්න.
පහත වැඩසටහන palindrome පරීක්ෂා කිරීමේ වැඩසටහන ක්‍රියාත්මක කරයි.
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) Reverse String Recursion Java
“Hello” තන්තුවක් ලබා දී ඇති විට අපට එය ආපසු හැරවිය යුතුය. ප්‍රතිඵලය වන තන්තුව “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); } } Output
#4) Binary Search Java Recursion
ද්විමය සෙවුම් ඇල්ගොරිතමයක් සෙවීම සඳහා ප්‍රසිද්ධ ඇල්ගොරිතමයකි. මෙම ඇල්ගොරිතමයේ දී, 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) Recursion භාවිතයෙන් Array හි අවම අගය සොයන්න
Recursion භාවිතා කිරීමෙන් අපට අරාවේ අවම අගයද සොයාගත හැක.
දarray එකේ අවම අගය සෙවීමට Java programme පහත දක්වා ඇත.
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"); } }Output
මේවායින් කිහිපයක් වේ. පුනරාවර්තන උදාහරණ. මෙම උදාහරණ හැරුණු විට, මෘදුකාංගයේ ඇති වෙනත් ගැටළු රාශියක් පුනරාවර්තන ශිල්පීය ක්‍රම භාවිතයෙන් ක්‍රියාත්මක කළ හැක.
Recursion Types
ප්‍රත්‍යාවර්තනය ඇමතීමේ අවස්ථාව මත පදනම්ව වර්ග දෙකකි. පුනරාවර්තන ක්‍රමය.
ඒවා නම්:
#1) Tail Recursion
ප්‍රත්‍යාවර්තී ක්‍රමයට ඇමතුම අවසාන ප්‍රකාශය වන විට ප්‍රත්‍යාවර්තී ක්‍රමය තුළ ක්‍රියාත්මක වන අතර, එය “ටේල් ප්‍රත්‍යාවර්තනය” ලෙස හැඳින්වේ.
වලිග ප්‍රත්‍යාවර්තනයේ දී, ප්‍රත්‍යාවර්තී ඇමතුම් ප්‍රකාශය සාමාන්‍යයෙන් ක්‍රමයේ ප්‍රතිලාභ ප්‍රකාශය සමඟ ක්‍රියාත්මක වේ.
tail recursion සඳහා වන සාමාන්‍ය වාක්‍ය ඛණ්ඩය පහත දක්වා ඇත:
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion } #2) Head Recursion
හිස් ප්‍රත්‍යාවර්තනය යනු වලිගය ප්‍රතිවර්තනයක් නොවන ඕනෑම ප්‍රත්‍යාවර්තක ප්‍රවේශයකි. එබැවින් සාමාන්‍ය ප්‍රත්‍යාවර්තනය පවා ඉදිරියෙන් ඇත.
ප්‍රධාන පුනරාවර්තනයේ වාක්‍ය ඛණ්ඩය පහත පරිදි වේ:
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) ප්‍රතිවර්තනයට වඩා ප්‍රත්‍යාවර්තනයේ වාසි මොනවාද?
පිළිතුර:
- ප්‍රතිවර්තනය කේතය පැහැදිලි සහ කෙටි කරයි.
- හැනොයි කුළුණ, ගස වැනි ගැටළු සඳහා පුනරාවර්තන ප්‍රවේශයට වඩා පුනරාවර්තනය හොඳය. ට්‍රැවර්සල් යනාදිය.
- සෑම ක්‍රියාකාරී ඇමතුමකම මතකය අට්ටියට තල්ලු කර ඇති බැවින්, ප්‍රත්‍යාවර්තනය වැඩි මතකයක් භාවිතා කරයි.
- ප්‍රතිවර්තන ප්‍රවේශයට වඩා ප්‍රත්‍යාවර්තන ක්‍රියාකාරිත්වය මන්දගාමී වේ.
නිගමනය
ක්‍රමලේඛන භාෂාව කුමක් වුවත් ප්‍රතිවර්තනය මෘදුකාංගයේ ඉතා වැදගත් සංකල්පයකි. ප්‍රත්‍යාවර්තනය බොහෝ දුරට භාවිතා වන්නේ හැනෝයි හි කුළුණු, ගස් ගමන්, සම්බන්ධිත ලැයිස්තු වැනි දත්ත ව්‍යුහ ගැටලු විසඳීමේදීය. එයට වැඩි මතකයක් අවශ්‍ය වුවද,පුනරාවර්තනය කේතය සරල සහ පැහැදිලි කරයි.
අපි මෙම නිබන්ධනය තුළ පුනරාවර්තනය පිළිබඳ සියල්ල ගවේෂණය කර ඇත. සංකල්පය පිළිබඳ වඩා හොඳ අවබෝධයක් සඳහා අපි බොහෝ ක්‍රමලේඛන උදාහරණ ද ක්‍රියාත්මක කර ඇත.