Java ရှိ Recursion နှင့်ပတ်သက်သော ဤ In-depth Tutorial တွင် Recursion ဟူသည် အဘယ်အရာကို ဥပမာများ၊ အမျိုးအစားများနှင့် ဆက်စပ်သော သဘောတရားများဖြင့် ရှင်းပြထားသည်။ ၎င်းသည် Recursion Vs Iteration ကိုလည်း အကျုံးဝင်သည်-
Java ရှိ ကျွန်ုပ်တို့၏အစောပိုင်းသင်ခန်းစာများမှ၊ ကျွန်ုပ်တို့သည် loop တစ်ခုကိုကြေငြာပြီး ထပ်ခါတလဲလဲလုပ်ဆောင်ခြင်းဖြင့် ဒေတာတည်ဆောက်ပုံမှတစ်ဆင့် ထပ်ကာထပ်ကာချဉ်းကပ်မှုကို ကျွန်ုပ်တို့တွေ့မြင်ရပါသည်။ အချိန်တစ်ခု။
loop variable သည် အခြေအနေနှင့် ကိုက်ညီသည့်တိုင်အောင် loop variable တစ်ခုကို သိမ်းဆည်းပြီး ကုဒ်အပိုင်းအစကို ထပ်ခါထပ်ခါ ပြုလုပ်သည့် conditional flow ကိုလည်း ကျွန်ုပ်တို့ တွေ့မြင်ခဲ့ရပါသည်။ လုပ်ဆောင်ချက်ခေါ်ဆိုမှုများနှင့်ပတ်သက်လာလျှင် ကျွန်ုပ်တို့သည် လုပ်ဆောင်ချက်ခေါ်ဆိုမှုများအတွက် ထပ်ခါတလဲလဲချဉ်းကပ်မှုကိုလည်း ရှာဖွေခဲ့သည်။
ဤသင်ခန်းစာတွင်၊ Recursive ချဉ်းကပ်မှုဖြစ်သည့် ပရိုဂရမ်ရေးဆွဲခြင်းဆိုင်ရာ ကွဲပြားသောချဉ်းကပ်နည်းကို ဆွေးနွေးပါမည်။
Java တွင် Recursion ဟူသည် အဘယ်နည်း။
Recursion သည် လုပ်ဆောင်ချက်တစ်ခု သို့မဟုတ် နည်းလမ်းတစ်ခုက သူ့ကိုယ်သူ ထပ်ခါထပ်ခါခေါ်ဆိုသည့် လုပ်ငန်းစဉ်တစ်ခုဖြစ်သည်။ တိုက်ရိုက် သို့မဟုတ် သွယ်ဝိုက်၍ဖြစ်စေ ထပ်ခါတလဲလဲခေါ်သော ဤလုပ်ဆောင်ချက်ကို "recursive function" ဟုခေါ်သည်။
ထပ်ခါထပ်ခါနားလည်ရန် ဥပမာအမျိုးမျိုးကို ကျွန်ုပ်တို့မြင်ရပါမည်။ ယခု ပြန်ရှာခြင်း၏ syntax ကို ကြည့်ကြပါစို့။
Recursion Syntax
Recursion ကို အကောင်အထည်ဖော်သည့် မည်သည့်နည်းလမ်းတွင်မဆို အခြေခံ အပိုင်းနှစ်ပိုင်းပါရှိသည်-
- မိမိကိုယ်ကို ပြန်ခေါ်နိုင်သည့်နည်းလမ်း ဆိုသည်မှာ recursive
- ပြန်ယူခြင်းကို ရပ်တန့်စေမည့် ကြိုတင်သတ်မှတ်ချက်တစ်ခုဖြစ်သည်။
ကျွန်ုပ်တို့မလုပ်ပါက ထပ်ခါတလဲလဲနည်းလမ်းအတွက် ကြိုတင်သတ်မှတ်ချက်တစ်ခု လိုအပ်ကြောင်း သတိပြုပါ။ ချိုးထို့နောက် ထပ်ခါတလဲလဲ အကန့်အသတ်မရှိ ဆက်လက်လည်ပတ်ပြီး stack overflow ဖြစ်ပေါ်စေပါမည်။
ပြန်ကုထုံး၏ ယေဘူယျ syntax မှာ အောက်ပါအတိုင်းဖြစ်သည်-
methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call } ကြိုတင်သတ်မှတ်ချက်ကိုလည်း ခေါ်ဆိုကြောင်း သတိပြုပါ။ အခြေခံအခြေအနေ။ နောက်အပိုင်းတွင် အခြေခံအခြေအနေအကြောင်း ပိုမိုဆွေးနွေးပါမည်။
Java တွင် ပြန်ယူခြင်းဆိုင်ရာ နားလည်ခြင်း
ဤအပိုင်းတွင်၊ ကျွန်ုပ်တို့သည် ပြန်ယူခြင်းလုပ်ငန်းစဉ်ကို နားလည်ရန် ကြိုးစားပြီး မည်သို့ဖြစ်ပျက်သည်ကို ကြည့်ရှုပါမည်။ အခြေခံအခြေအနေ၊ stack overflow အကြောင်း လေ့လာပြီး ပြဿနာတစ်ခုအား ပြန်ကောက်ချက်နှင့် အခြားအသေးစိတ်အချက်အလက်များဖြင့် ဖြေရှင်းနိုင်ပုံကို ကြည့်ရှုပါမည်။
Recursion Base Condition
recursive ပရိုဂရမ်ကို ရေးနေချိန်တွင်၊ အခြေခံကိစ္စအတွက် ပထမဦးစွာ ဖြေရှင်းချက်ပေးပါ။ ထို့နောက် အသေးအမွှားပြဿနာများအတွက် ပိုကြီးသောပြဿနာကို ဖော်ပြပါသည်။
နမူနာအနေဖြင့်၊ ဂဏန်းတစ်ခု၏ factorial ကိုတွက်ချက်ခြင်း၏ ဂန္တဝင်ပုစ္ဆာတစ်ပုဒ်ကို ကျွန်ုပ်တို့ယူနိုင်ပါသည်။ နံပါတ် n ကိုပေးခြင်းဖြင့်၊ n ဖြင့်ဖော်ပြသော ကိန်းဂဏာန်းတစ်ခုအား ကျွန်ုပ်တို့ရှာဖွေရပါမည်။
ယခု recursion ကိုအသုံးပြု၍ n factorial (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 သို့ပြန်သွားသည် လုပ်ဆောင်ချက်၏ အခြားအစိတ်အပိုင်းမှာ recursive call ဖြစ်သည်။ သို့သော် recursive method ကိုခေါ်တိုင်း n ကို 1 ဖြင့် လျှော့ချသည်။
ထို့ကြောင့် နောက်ဆုံးတွင် n ၏တန်ဖိုးသည် 1 သို့မဟုတ် 1 ထက်နည်းသွားမည်ဖြစ်ကြောင်း ကျွန်ုပ်တို့ကောက်ချက်ချနိုင်ပါသည်။point၊ method သည် value 1 ကို ပြန်ပေးပါမည်။ ဤအခြေခံအခြေအနေသို့ရောက်ရှိပြီး function ရပ်တန့်သွားမည်ဖြစ်ပါသည်။ n ၏တန်ဖိုးသည် အခြေခံအခြေအနေအား ကျေနပ်နေသရွေ့ မည်သည့်အရာမဆို ဖြစ်နိုင်ကြောင်း သတိပြုပါ။
Recursion ကိုအသုံးပြုခြင်းဖြင့် ပြဿနာဖြေရှင်းခြင်း
ပြန်လည်ကုထုံးကို အသုံးပြုခြင်း၏ နောက်ကွယ်တွင် အခြေခံအယူအဆမှာ ပိုကြီးသောပြဿနာကို ဖော်ပြရန်ဖြစ်သည်။ သေးငယ်သောပြဿနာများ။ ထို့အပြင်၊ ကျွန်ုပ်တို့သည် ပြန်ယူခြင်းမှ ထွက်လာနိုင်စေရန် တစ်ခု သို့မဟုတ် တစ်ခုထက်ပိုသော အခြေခံအခြေအနေများကို ထည့်သွင်းရန် လိုအပ်ပါသည်။
၎င်းကို အထက်ပါ Factorial ဥပမာတွင် သရုပ်ပြထားပြီးဖြစ်သည်။ ဤပရိုဂရမ်တွင်၊ ကျွန်ုပ်တို့သည် n factorial (n!) ကို သေးငယ်သောတန်ဖိုးများနှင့်အညီ ဖော်ပြခဲ့ပြီး အခြေခံအခြေအနေ (n =1) ရှိသည် ထို့ကြောင့် n သည် 1 သို့ရောက်ရှိသောအခါ၊ ကျွန်ုပ်တို့သည် recursive နည်းလမ်းကို နှုတ်ထွက်နိုင်ပါသည်။
Recursion တွင် Stack Overflow Error
မည်သည့်နည်းလမ်း သို့မဟုတ် လုပ်ဆောင်ချက်ကိုမဆို ခေါ်သောအခါ၊ လုပ်ဆောင်ချက်၏ အခြေအနေအား stack တွင် သိမ်းဆည်းပြီး လုပ်ဆောင်ချက် ပြန်တက်လာသောအခါ ပြန်လည်ရယူကြောင်း ကျွန်ုပ်တို့ သိရှိပါသည်။ stack ကိုလည်း recursive method အတွက်လည်း အသုံးပြုပါသည်။
သို့သော် ထပ်ခါတလဲလဲလုပ်သည့်အခါတွင်၊ base condition ကို မသတ်မှတ်ထားပါက သို့မဟုတ် base condition သည် တစ်နည်းနည်းဖြင့် မရောက်နိုင် သို့မဟုတ် မလုပ်ဆောင်ပါက ပြဿနာတစ်ခု ဖြစ်လာနိုင်သည်။ အကယ်၍ ဤအခြေအနေမျိုး ဖြစ်ပေါ်လာပါက stack overflow ဖြစ်ပေါ်လာနိုင်ပါသည်။
factoryal notation ၏ အောက်ဖော်ပြပါ ဥပမာကို သုံးသပ်ကြည့်ကြပါစို့။
ဤတွင် ကျွန်ုပ်တို့သည် မှားယွင်းသော အခြေခံအခြေအနေတစ်ခုကို ပေးထားပါသည်။ နည်းလမ်း 100 သည် 1 သို့ပြန်သွားလိမ့်မည်၊ သို့သော် ပြန်ယူခြင်းသည် ရပ်တန့်မည်မဟုတ်ပါ။ n ၏တန်ဖိုးသည် ထိုနေရာအတိုင်း အကန့်အသတ်မရှိ ဆက်လက်ကျဆင်းနေလိမ့်မည်။အဲဒါကို တားဖို့ တခြား အခြေအနေ မရှိပါဘူး။ အစုအစည်းများ ပြည့်သွားသည်အထိ ဤအရာသည် ဆက်သွားပါမည်။
နောက်ထပ် ကိစ္စတစ်ခုမှာ n ၏တန်ဖိုးဖြစ်သည့်အခါ ဖြစ်လိမ့်မည်။ 100. ဤအခြေအနေတွင်၊ နည်းလမ်းသည် အခြေခံအခြေအနေအား မည်သည့်အခါမျှ လုပ်ဆောင်မည်မဟုတ်သည့်အပြင် stack overflow ဖြစ်စေပါသည်။
Recursion Examples in Java
ဤကဏ္ဍတွင်၊ ကျွန်ုပ်တို့သည် အောက်ပါနမူနာများကို အသုံးပြု၍ အကောင်အထည်ဖော်ပါမည်။ ပြန်ကောက်ချက်။
#1) Fibonacci Series Recursion ကိုအသုံးပြုခြင်း
Fibonacci စီးရီးကို၊
1,1,2,3,5,8,13,21၊ ၃၇၊ ထို့အပြင်၊ 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) + " "); } } } Output
#2) Recursion ကိုအသုံးပြုသည့် Palindrome နံပါတ်တစ်ခုဟုတ်မဟုတ် စစ်ဆေးပါ
palindrome သည် ကျွန်ုပ်တို့လုပ်ဆောင်သောအခါ တူညီသော sequence တစ်ခုဖြစ်သည်။ ဘယ်မှညာမှ ညာသို့ ဘယ်သို့ဖတ်ပါ။
နံပါတ် 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."); } } }Output
#3) Reverse String Recursion Java
ပေးထားသော string “Hello” သို့ ပြောင်းပြန်လှန်ရန် လိုအပ်ပါသည်။ ထွက်ပေါ်လာသောစာကြောင်းမှာ “olleH” ဖြစ်သည်။
၎င်းကို ပြန်ကောက်ချက်ဖြင့် လုပ်ဆောင်သည်။ string ရှိ နောက်ဆုံးစာလုံးမှ စတင်၍ string ရှိ စာလုံးအားလုံး ကုန်ဆုံးသည်အထိ စာလုံးတစ်ခုစီကို ထပ်ခါတလဲလဲ ရိုက်နှိပ်ပါသည်။
အောက်ပါပရိုဂရမ်သည် ပေးထားသောစာကြောင်းကို ပြောင်းပြန်လှန်ရန် recursion ကို အသုံးပြုပါသည်။
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 ဒြပ်စင်များ စီထားသော အာရီခင်းကို ပေးထားသည့် ဤ algorithm တွင်၊ ကျွန်ုပ်တို့သည် ပေးထားသော သော့ဒြပ်စင်အတွက် ဤအခင်းအကျင်းကို ရှာဖွေသည်။ အစပိုင်းတွင်၊ array ၏အလယ်ဒြပ်ကိုရှာဖွေခြင်းဖြင့် array ကို နှစ်ပိုင်းခွဲထားသည်။
ထို့နောက် သော့အလယ်သည် ကျွန်ုပ်တို့၏ရှာဖွေမှုကို array ၏ပထမ သို့မဟုတ် ဒုတိယတစ်ဝက်တွင် ကန့်သတ်ထားခြင်းရှိမရှိအပေါ် မူတည်သည်။ ဤနည်းဖြင့် တူညီသောလုပ်ငန်းစဉ်သည် အဓိကဒြပ်စင်များ၏တည်နေရာကိုမတွေ့မချင်း ထပ်ခါတလဲလဲလုပ်ဆောင်ပါသည်။
ဤနေရာတွင် recursion ကိုအသုံးပြု၍ ဤ algorithm ကိုအကောင်အထည်ဖော်ပါမည်။
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); } } Output
#5) Recursion ကိုအသုံးပြုပြီး Array တွင် အနည်းဆုံးတန်ဖိုးကိုရှာပါ
ပြန်ယူခြင်းကိုအသုံးပြုခြင်းဖြင့် array အတွင်းရှိ အနည်းဆုံးတန်ဖိုးကိုလည်း ရှာတွေ့နိုင်ပါသည်။
ထိုarray ရှိ အနည်းဆုံးတန်ဖိုးကို ရှာရန် Java ပရိုဂရမ်ကို အောက်တွင်ပေးထားသည်။
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 ၏ဥပမာများ။ ဤနမူနာများမှလွဲ၍ ဆော့ဖ်ဝဲရှိ အခြားပြဿနာများစွာကို ထပ်ခါတလဲလဲလုပ်ထုံးလုပ်နည်းများကို အသုံးပြုပြီး အကောင်အထည်ဖော်နိုင်ပါသည်။
Recursion Types
ခေါ်ဆိုမှုပြုလုပ်သည့်အခါတွင် အခြေခံ၍ ပြန်ကောက်ခြင်းမှာ အမျိုးအစားနှစ်မျိုးရှိသည်။ ပြန်ယူနည်း။
၎င်းတို့မှာ-
#1) Tail Recursion
ပြန်ကောက်နည်းကို ခေါ်ဆိုသောအခါ နောက်ဆုံးထုတ်ပြန်ချက်ဖြစ်သည်။ recursive method အတွင်းတွင် လုပ်ဆောင်ခဲ့သည်၊ ၎င်းကို "Tail Recursion" ဟုခေါ်သည်။
အမြီးပြန်ကောက်ခြင်းတွင်၊ recursive call statement ကို method ၏ return statement နှင့်အတူ လုပ်ဆောင်လေ့ရှိပါသည်။
The အမြီးပြန်ယူခြင်းအတွက် ယေဘူယျအသုံးအနှုန်းကို အောက်တွင်ဖော်ပြထားသည်-
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion } #2) Head Recursion
ခေါင်းပြန်ကုထုံးသည် tail recursion မဟုတ်သော မည်သည့် recursive ချဉ်းကပ်မှုမဆိုဖြစ်သည်။ ထို့ကြောင့် ယေဘူယျအားဖြင့် ထပ်ခါတလဲလဲခြင်းပင်လျှင် ရှေ့သို့ပြန်ပြန်ခြင်းပင်ဖြစ်သည်။
ခေါင်းပြန်ကုထုံး၏ Syntax မှာ အောက်ပါအတိုင်းဖြစ်သည်-
methodName (T parameters…){ if (some_condition == true) { return methodName (T parameters…); } return result; } Recursion Vs Iteration in Java
| Recursion | Iteration |
|---|---|
| Recursion သည် base condition မပြည့်မီမချင်း ၎င်းကို ထပ်ခါတလဲလဲခေါ်ဆိုသည့် လုပ်ငန်းစဉ်တစ်ခုဖြစ်သည်။ | ထပ်ခါထပ်ခါပြုလုပ်ခြင်းဖြစ်သည် ကန့်သတ်နံပါတ်တစ်ခုအတွက် သို့မဟုတ် အခြေအနေတစ်ခု ပြည့်မီသည်အထိ ကုဒ်အပိုင်းတစ်ခုကို ထပ်ခါတလဲလဲ လုပ်ဆောင်သည့် လုပ်ငန်းစဉ်တစ်ခု။ |
| လုပ်ဆောင်ချက်များအတွက် အပလီကေးရှင်းဖြစ်ပါသလား။ | အသုံးပြုနိုင်ပါသည်။ ကွက်များအတွက်။ |
| အတွက် ကောင်းစွာအလုပ်လုပ်သည်။ပိုသေးငယ်သော ကုဒ်အရွယ်အစား။ | ပိုကြီးသော ကုဒ်အရွယ်အစားအတွက် ကောင်းမွန်စွာ အလုပ်လုပ်ပါသည်။ |
| ထပ်ခါတလဲလဲခေါ်ဆိုမှုတစ်ခုစီကို stack သို့ တွန်းပို့သောကြောင့် မှတ်ဉာဏ်ပိုမိုအသုံးပြုသည် | နှိုင်းယှဉ်ပါက မှတ်ဉာဏ်နည်းပါသည်။ အသုံးပြုထားသည်။ |
| အမှားရှာပြင်ရန်နှင့် ထိန်းသိမ်းရန်ခက်ခဲ | အမှားရှာရန်နှင့် ထိန်းသိမ်းရန်ပိုမိုလွယ်ကူ |
| အခြေတည်ပါက stack overflow ရလဒ်များ အခြေအနေများကို သတ်မှတ်ထားခြင်း သို့မဟုတ် မရောက်ရှိသေးပါ။ | အကန့်အသတ်မရှိ လုပ်ဆောင်နိုင်သော်လည်း မှတ်ဉာဏ်အမှားအယွင်းများရှိပါက နောက်ဆုံးတွင် လုပ်ဆောင်မှုကို ရပ်သွားလိမ့်မည် |
| အချိန်ရှုပ်ထွေးမှုသည် အလွန်မြင့်မားသည်။ | အချိန်၏ရှုပ်ထွေးမှုသည် အောက်ခြေတွင်ရှိသည်။ |
အမေးများသောမေးခွန်းများ
မေး #1) Recursion သည် Java တွင် မည်သို့အလုပ်လုပ်သနည်း။
အဖြေ- ပြန်ယူခြင်းတွင်၊ အခြေခံအခြေအနေတစ်ခု ကျေနပ်သည်အထိ ထပ်ခါတလဲလဲ ပြန်ခေါ်သည့်လုပ်ဆောင်ချက်သည် သူ့ကိုယ်သူ အကြိမ်ကြိမ်ခေါ်ဆိုသည်။ ခေါ်ဆိုမှုလုပ်ဆောင်ချက်အတွက် မမ်မိုရီကို မမ်မိုရီ၏ထိပ်ရှိ stack သို့ တွန်းပို့သည်။ လုပ်ဆောင်ချက်ခေါ်ဆိုမှုတစ်ခုစီအတွက်၊ ဒေသဆိုင်ရာ ကိန်းရှင်များကို သီးခြားမိတ္တူတစ်ခု ပြုလုပ်ထားသည်။
မေး #2) အဘယ်ကြောင့် Recursion ကို အသုံးပြုသနည်း။
အဖြေ- Recursion ကို အသေးအမွှားများအဖြစ် ခွဲထုတ်နိုင်သော အဆိုပါပြဿနာများကို ဖြေရှင်းရန်အတွက် အသုံးပြုပြီး ပြဿနာတစ်ခုလုံးကို သေးငယ်သောပြဿနာတစ်ခုအဖြစ် ဖော်ပြနိုင်ပါသည်။
ထိုပြဿနာများအတွက်လည်း Recursion ကို အသုံးပြုပါသည်။ ထပ်ခါထပ်ခါ ချဉ်းကပ်နည်းဖြင့် ဖြေရှင်းရန် ရှုပ်ထွေးသည်။ အချိန်ရှုပ်ထွေးမှုပြဿနာမဟုတ်သည့် ပြဿနာများအပြင်၊ ပြန်လှည့်ခြင်းကို အသုံးပြုပါ။
မေးခွန်း #3) အကျိုးကျေးဇူးများကား အဘယ်နည်း။Recursion?
အဖြေ-
Recursion ၏ အကျိုးကျေးဇူးများတွင်-
- Recursion သည် ထပ်ကာထပ်ကာခေါ်ဆိုမှုကို လျှော့ချပေးသည် လုပ်ဆောင်ချက်။
- Recursion သည် ထပ်ခါထပ်ခါ ချဉ်းကပ်နည်းနှင့် နှိုင်းယှဉ်လျှင် ပြဿနာများကို အလွယ်တကူ ဖြေရှင်းနိုင်စေပါသည်။
Q #4) ဘယ်တစ်ခုက ပိုကောင်းလဲ – Recursion သို့မဟုတ် Iteration?
အဖြေ- Recursion သည် အခြေခံလုပ်ဆောင်ချက်မပြီးမချင်း ထပ်ခါတလဲလဲခေါ်ဆိုမှုများ ပြုလုပ်သည်။ ထို့ကြောင့် လုပ်ဆောင်ချက်တစ်ခုစီအတွက် ခေါ်ဆိုမှုတစ်ခုစီအတွက် မမ်မိုရီတစ်ခုစီကို stack သို့ တွန်းချသည့်အတွက် မမ်မိုရီအပေါ်တွင် ရှိနေပါသည်။
အခြားတစ်ဖက်တွင် ထပ်လောင်းခြင်းမှာ မန်မိုရီအပေါ်တွင် များစွာမရှိပါ။ ထပ်ခါထပ်ခါ ချဉ်းကပ်မှုထက် နှေးကွေးသည်။ ထပ်ခါတလဲလဲ ချဉ်းကပ်ခြင်းသည် ကုဒ်ကို ကြီးမားစေသော်လည်း ထပ်ခါတလဲလဲ ကုဒ်၏ အရွယ်အစားကို လျှော့ချပေးပါသည်။
မေး #5) ထပ်ခါထပ်ခါ ထပ်ခါထပ်ခါ ချဉ်းကပ်ခြင်း၏ အားသာချက်များကား အဘယ်နည်း။
အဖြေ-
- Recursion သည် ကုဒ်ကို ပိုမိုရှင်းလင်းစေပြီး တိုတောင်းစေသည်။
- Recursion သည် ဟနွိုင်းမျှော်စင်၊ သစ်ပင်ကဲ့သို့သော ပြဿနာများအတွက် ထပ်ခါထပ်ခါ ချဉ်းကပ်ခြင်းထက် ပိုကောင်းပါသည်။ ဖြတ်သန်းမှုများ၊ စသည်တို့။
- လုပ်ဆောင်ချက်ခေါ်ဆိုမှုတိုင်းတွင် မမ်မိုရီကို stack သို့ တွန်းပို့သည်နှင့်အမျှ၊ Recursion သည် မှတ်ဉာဏ်ပိုမိုအသုံးပြုပါသည်။
- ပြန်ယူခြင်းစွမ်းဆောင်ရည်သည် ထပ်ခါထပ်ခါချဉ်းကပ်မှုထက် နှေးကွေးပါသည်။
နိဂုံးချုပ်
Recursion သည် ပရိုဂရမ်းမင်းဘာသာစကားကို မခွဲခြားဘဲ ဆော့ဖ်ဝဲတွင် အလွန်အရေးကြီးသော အယူအဆတစ်ခုဖြစ်သည်။ Recursion ကို ဟနွိုင်းမျှော်စင်များ၊ သစ်ပင်ဖြတ်သန်းမှုများ၊ ချိတ်ဆက်ထားသောစာရင်းများ စသည်တို့ကဲ့သို့ ဒေတာဖွဲ့စည်းပုံဆိုင်ရာ ပြဿနာများကို ဖြေရှင်းရာတွင် အများစုအသုံးပြုသည်။ ၎င်းသည် မှတ်ဉာဏ်ပိုယူသော်လည်း၊recursion သည် ကုဒ်ကို ပိုမိုရိုးရှင်းစေပြီး ပိုမိုရှင်းလင်းစေသည်။
ဤသင်ခန်းစာတွင် Recursion အကြောင်းအားလုံးကို ကျွန်ုပ်တို့ ရှာဖွေပြီးပါပြီ။ သဘောတရားကို ပိုမိုကောင်းမွန်စွာ နားလည်နိုင်စေရန်အတွက် ပရိုဂရမ်းမင်းနမူနာများစွာကိုလည်း ကျွန်ုပ်တို့ အကောင်အထည်ဖော်ခဲ့ပါသည်။