ການສອນແບບເຈາະເລິກນີ້ກ່ຽວກັບ Recursion ໃນ Java ອະທິບາຍສິ່ງທີ່ເປັນ Recursion ດ້ວຍຕົວຢ່າງ, ປະເພດ ແລະແນວຄວາມຄິດທີ່ກ່ຽວຂ້ອງ. ມັນຍັງກວມເອົາ Recursion Vs Iteration:
ຈາກການສອນກ່ອນໜ້ານີ້ຂອງພວກເຮົາໃນ Java, ພວກເຮົາໄດ້ເຫັນວິທີການຊ້ຳກັນທີ່ພວກເຮົາປະກາດເປັນ loop ແລະຫຼັງຈາກນັ້ນຂ້າມຜ່ານໂຄງສ້າງຂໍ້ມູນໃນລັກສະນະຊໍ້າຊ້ອນໂດຍການເອົາອົງປະກອບຫນຶ່ງຢູ່ທີ່ a time.
ພວກເຮົາຍັງໄດ້ເຫັນການໄຫຼຕາມເງື່ອນໄຂທີ່ອີກເທື່ອຫນຶ່ງພວກເຮົາເກັບຕົວແປ loop ຫນຶ່ງແລະເຮັດຊ້ໍາຊິ້ນສ່ວນຂອງລະຫັດຈົນກ່ວາຕົວແປ loop ຕອບສະຫນອງເງື່ອນໄຂ. ເມື່ອເວົ້າເຖິງການເອີ້ນຟັງຊັນ, ພວກເຮົາໄດ້ສຳຫຼວດວິທີການໂທແບບຊ້ຳໆສຳລັບການເອີ້ນຟັງຊັນເຊັ່ນກັນ.
ໃນບົດສອນນີ້, ພວກເຮົາຈະສົນທະນາວິທີການທີ່ແຕກຕ່າງກັນຂອງການຂຽນໂປລແກລມເຊັ່ນ: ວິທີການ Recursive.
Recursion ໃນ Java ແມ່ນຫຍັງ?
Recursion ແມ່ນຂະບວນການທີ່ຟັງຊັນ ຫຼືວິທີການເອີ້ນຕົວມັນເອງອີກຄັ້ງ ແລະອີກຄັ້ງ. ຟັງຊັນນີ້ທີ່ຖືກເອີ້ນອີກແລ້ວໂດຍກົງ ຫຼືທາງອ້ອມແມ່ນເອີ້ນວ່າ "ຟັງຊັນ recursive".
ພວກເຮົາຈະເຫັນຕົວຢ່າງຕ່າງໆເພື່ອເຂົ້າໃຈ recursion. ຕອນນີ້ໃຫ້ເບິ່ງ syntax ຂອງ recursion.
Recursion Syntax
ວິທີໃດກໍໄດ້ທີ່ປະຕິບັດ Recursion ມີສອງສ່ວນພື້ນຖານ:
- ການເອີ້ນວິທີການທີ່ສາມາດເອີ້ນຕົວມັນເອງເຊັ່ນ: recursive
- ເງື່ອນໄຂເບື້ອງຕົ້ນທີ່ຈະຢຸດການເອີ້ນຄືນ. ທໍາລາຍrecursion ຫຼັງຈາກນັ້ນມັນຈະດໍາເນີນການຕໍ່ໄປຢ່າງບໍ່ມີຂອບເຂດແລະສົ່ງຜົນໃຫ້ stack overflow.
syntax ທົ່ວໄປຂອງ recursion ມີດັ່ງນີ້:
methodName (T parameters…) { if (precondition == true) //precondition or base condition { return result; } return methodName (T parameters…); //recursive call }ໃຫ້ສັງເກດວ່າ precondition ເອີ້ນວ່າຍັງ. ສະພາບພື້ນຖານ. ພວກເຮົາຈະສົນທະນາເພີ່ມເຕີມກ່ຽວກັບເງື່ອນໄຂພື້ນຖານໃນພາກຕໍ່ໄປ.
ຄວາມເຂົ້າໃຈ Recursion ໃນ Java
ໃນພາກນີ້, ພວກເຮົາຈະພະຍາຍາມເຂົ້າໃຈຂະບວນການ recursion ແລະເບິ່ງວ່າມັນເກີດຂຶ້ນແນວໃດ. ພວກເຮົາຈະຮຽນຮູ້ກ່ຽວກັບສະພາບພື້ນຖານ, stack overflow, ແລະເບິ່ງວ່າບັນຫາໃດນຶ່ງສາມາດແກ້ໄຂໄດ້ດ້ວຍ recursion ແລະລາຍລະອຽດອື່ນໆ.
Recursion Base Condition
ໃນຂະນະທີ່ຂຽນໂປຣແກຣມ recursive, ພວກເຮົາຄວນ ທໍາອິດໃຫ້ການແກ້ໄຂສໍາລັບກໍລະນີພື້ນຖານ. ຫຼັງຈາກນັ້ນ, ພວກເຮົາສະແດງບັນຫາທີ່ໃຫຍ່ກວ່າໃນແງ່ຂອງບັນຫາທີ່ນ້ອຍກວ່າ.
ເປັນຕົວຢ່າງ , ພວກເຮົາສາມາດເອົາບັນຫາຄລາສສິກຂອງການຄໍານວນ factorial ຂອງຕົວເລກ. ເມື່ອມີຕົວເລກ n, ພວກເຮົາຕ້ອງຊອກຫາ factorial ຂອງ n ແທນດ້ວຍ n!
ຕອນນີ້ໃຫ້ໃຊ້ໂປຣແກຣມເພື່ອຄິດໄລ່ຄ່າ n factorial (n!) ໂດຍໃຊ້ recursion.
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. ແຕ່ທຸກໆຄັ້ງທີ່ວິທີການ recursive ຖືກເອີ້ນ, n ຖືກຫຼຸດລົງໂດຍ 1.
ດັ່ງນັ້ນພວກເຮົາສາມາດສະຫຼຸບໄດ້ວ່າໃນທີ່ສຸດຄ່າຂອງ n ຈະກາຍເປັນ 1 ຫຼືຫນ້ອຍກວ່າ 1 ແລະໃນນີ້.ຈຸດ, ວິທີການຈະກັບຄືນຄ່າ 1. ເງື່ອນໄຂພື້ນຖານນີ້ຈະຖືກບັນລຸແລະຟັງຊັນຈະຢຸດ. ໃຫ້ສັງເກດວ່າຄ່າຂອງ n ສາມາດເປັນອັນໃດກໍໄດ້ເທົ່າທີ່ມັນຕອບສະໜອງເງື່ອນໄຂພື້ນຖານ. ບັນຫາຂະຫນາດນ້ອຍກວ່າ. ນອກຈາກນັ້ນ, ພວກເຮົາຈໍາເປັນຕ້ອງເພີ່ມເງື່ອນໄຂພື້ນຖານຫນຶ່ງຫຼືຫຼາຍກວ່ານັ້ນເພື່ອໃຫ້ພວກເຮົາສາມາດອອກຈາກການເອີ້ນຄືນໃຫມ່. ໃນໂປຣແກຣມນີ້, ພວກເຮົາໄດ້ສະແດງຄ່າ n factorial (n!) ໃນແງ່ຂອງຄ່າທີ່ນ້ອຍກວ່າ ແລະ ມີເງື່ອນໄຂພື້ນຖານ (n =1) ດັ່ງນັ້ນເມື່ອ n ຮອດ 1, ພວກເຮົາສາມາດອອກຈາກວິທີການ recursive ໄດ້.
Stack Overflow Error in Recursion
ພວກເຮົາຮູ້ວ່າເມື່ອວິທີການ ຫຼືຟັງຊັນໃດຖືກເອີ້ນ, ສະຖານະຂອງຟັງຊັນຈະຖືກເກັບໄວ້ໃນ stack ແລະຖືກດຶງມາເມື່ອຟັງຊັນກັບຄືນມາ. stack ແມ່ນໃຊ້ສໍາລັບວິທີການ recursive ເຊັ່ນດຽວກັນ.
ແຕ່ໃນກໍລະນີຂອງ recursion, ບັນຫາອາດຈະເກີດຂຶ້ນຖ້າຫາກວ່າພວກເຮົາບໍ່ໄດ້ກໍານົດເງື່ອນໄຂພື້ນຖານຫຼືໃນເວລາທີ່ເງື່ອນໄຂພື້ນຖານແມ່ນ somehow ບໍ່ໄດ້ບັນລຸຫຼືປະຕິບັດ. ຖ້າສະຖານະການນີ້ເກີດຂຶ້ນ, stack overflow ອາດຈະເກີດຂຶ້ນ.
ໃຫ້ພິຈາລະນາຕົວຢ່າງຂ້າງລຸ່ມນີ້ຂອງ factorial notation.
ນີ້ພວກເຮົາໄດ້ໃຫ້ເງື່ອນໄຂພື້ນຖານທີ່ບໍ່ຖືກຕ້ອງ, 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 ແຕ່ recursion ຈະບໍ່ຢຸດ. ຄ່າຂອງ n ຈະສືບຕໍ່ຫຼຸດລົງຢ່າງບໍ່ມີກຳນົດຕາມທີ່ນັ້ນບໍ່ມີເງື່ອນໄຂອື່ນທີ່ຈະຢຸດມັນ. ນີ້ຈະດໍາເນີນຕໍ່ໄປຈົນກ່ວາ stack overflows.
ກໍລະນີອື່ນຈະເປັນເວລາທີ່ຄ່າຂອງ n 100. ໃນກໍລະນີນີ້, ເຊັ່ນດຽວກັນວິທີການຈະບໍ່ປະຕິບັດສະພາບພື້ນຖານແລະເຮັດໃຫ້ເກີດ stack overflow.
ຕົວຢ່າງ Recursion ໃນ Java
ໃນພາກນີ້, ພວກເຮົາຈະປະຕິບັດຕົວຢ່າງດັ່ງຕໍ່ໄປນີ້ໂດຍການນໍາໃຊ້. recursion.
#1) Fibonacci Series ການນໍາໃຊ້ Recursion
ຊຸດ Fibonacci ແມ່ນໃຫ້ໂດຍ,
1,1,2,3,5,8,13,21, 34,55,…
ລຳດັບຂ້າງເທິງສະແດງໃຫ້ເຫັນວ່າອົງປະກອບປັດຈຸບັນແມ່ນຜົນລວມຂອງສອງອົງປະກອບກ່ອນໜ້າ. ນອກຈາກນັ້ນ, ອົງປະກອບທໍາອິດໃນຊຸດ Fibonacci ແມ່ນ 1.
ດັ່ງນັ້ນໂດຍທົ່ວໄປແລ້ວຖ້າຫາກວ່າ n ເປັນຈໍານວນປະຈຸບັນ, ຫຼັງຈາກນັ້ນມັນຈະຖືກມອບໃຫ້ໂດຍຜົນລວມຂອງ (n-1) ແລະ (n-2). ເນື່ອງຈາກອົງປະກອບປັດຈຸບັນຖືກສະແດງອອກໃນແງ່ຂອງອົງປະກອບທີ່ຜ່ານມາ, ພວກເຮົາສາມາດສະແດງບັນຫານີ້ໂດຍໃຊ້ recursion.
ໂຄງການເພື່ອປະຕິບັດຊຸດ 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) ກວດເບິ່ງວ່າຕົວເລກແມ່ນ Palindrome ໂດຍໃຊ້ Recursion
A 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."); } } }0 Output
#3) Reverse String Recursion Java
ໃຫ້ string “ສະບາຍດີ” ພວກເຮົາຕ້ອງປີ້ນກັບມັນເພື່ອໃຫ້ string ຜົນໄດ້ຮັບແມ່ນ “olleH”.
ອັນນີ້ແມ່ນເຮັດໄດ້ໂດຍໃຊ້ 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
A binary search algorithm is a famous algorithm for searching. ໃນ algorithm ນີ້, ການຈັດລຽງ array ຂອງອົງປະກອບ n, ພວກເຮົາຄົ້ນຫາ array ນີ້ສໍາລັບອົງປະກອບທີ່ສໍາຄັນ. ໃນຕອນເລີ່ມຕົ້ນ, ພວກເຮົາແບ່ງ array ອອກເປັນສອງເຄິ່ງໂດຍການຊອກຫາອົງປະກອບກາງຂອງ array.
ຈາກນັ້ນຂຶ້ນຢູ່ກັບວ່າຄີກາງພວກເຮົາຈໍາກັດການຄົ້ນຫາຂອງພວກເຮົາໃນເຄິ່ງທໍາອິດຫຼືທີສອງຂອງ array. ດ້ວຍວິທີນີ້, ຂະບວນການດຽວກັນຈະຖືກເຮັດຊ້ໍາອີກຈົນກວ່າຈະພົບເຫັນສະຖານທີ່ຂອງອົງປະກອບທີ່ສໍາຄັນ.
ພວກເຮົາຈະປະຕິບັດ algorithm ນີ້ໂດຍໃຊ້ recursion ທີ່ນີ້.
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) ຊອກຫາຄ່າຕໍ່າສຸດໃນ Array ໂດຍໃຊ້ Recursion
ການໃຊ້ recursion ພວກເຮົາຍັງສາມາດຊອກຫາຄ່າຕໍ່າສຸດໃນ Array ໄດ້.
ໄດ້ໂປຣແກຣມ Java ເພື່ອຊອກຫາຄ່າຕໍ່າສຸດໃນ array ແມ່ນໃຫ້ຢູ່ລຸ່ມນີ້.
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. ນອກເຫນືອຈາກຕົວຢ່າງເຫຼົ່ານີ້, ບັນຫາອື່ນໆຈໍານວນຫຼາຍໃນຊອບແວສາມາດຖືກປະຕິບັດໂດຍໃຊ້ເຕັກນິກການເອີ້ນຄືນໃຫມ່. ວິທີການ recursive.
ພວກມັນຄື:
#1) Tail Recursion
ເມື່ອການໂທຫາວິທີການ recursive ແມ່ນຄໍາຖະແຫຼງສຸດທ້າຍ. ປະຕິບັດພາຍໃນວິທີການ recursive, ມັນຖືກເອີ້ນວ່າ "Tail Recursion".
ໃນ tail recursion, ຄໍາສັ່ງ recursive ປົກກະຕິແລ້ວແມ່ນປະຕິບັດພ້ອມກັບຄໍາຖະແຫຼງການກັບຄືນຂອງວິທີການ.
The syntax ທົ່ວໄປສໍາລັບການ recursion ຫາງແມ່ນໃຫ້ຂ້າງລຸ່ມນີ້:
methodName ( T parameters…){ { if (base_condition == true) { return result; } return methodName (T parameters …) //tail recursion }#2) Head Recursion
Head recursion ແມ່ນວິທີການ recursive ໃດໆທີ່ບໍ່ແມ່ນ recursion ຫາງ. ສະນັ້ນເຖິງແມ່ນ recursion ທົ່ວໄປແມ່ນເປັນ recursion ລ່ວງໜ້າ.
Syntax of head recursion ມີດັ່ງນີ້:
methodName (T parameters…){ if (some_condition == true) { return methodName (T parameters…); } return result; }Recursion Vs Iteration In Java
Recursion Iteration Recursion ແມ່ນຂະບວນການທີ່ວິທີການເອີ້ນຕົວມັນເອງຊ້ຳໆຈົນກວ່າເງື່ອນໄຂພື້ນຖານຈະບັນລຸໄດ້. ການຊໍ້າຄືນແມ່ນ ຂະບວນການທີ່ຊິ້ນສ່ວນຂອງລະຫັດຖືກປະຕິບັດຊ້ຳໆເປັນຈຳນວນຈຳກັດຂອງເທື່ອ ຫຼືຈົນກວ່າເງື່ອນໄຂຈະບັນລຸໄດ້. ແມ່ນແອັບພລິເຄຊັນສຳລັບຟັງຊັນ. ສາມາດໃຊ້ໄດ້. ສໍາລັບ loops. ໃຊ້ໄດ້ດີກັບຂະໜາດລະຫັດທີ່ນ້ອຍກວ່າ. ໃຊ້ໄດ້ດີກັບຂະໜາດລະຫັດທີ່ໃຫຍ່ກວ່າ. ໃຊ້ໜ່ວຍຄວາມຈຳຫຼາຍຂຶ້ນ ເນື່ອງຈາກແຕ່ລະສາຍໂທຊ້ຳໆຖືກດັນໄປໃສ່ stack ເມື່ອປຽບທຽບກັບຄວາມຈຳໜ້ອຍກວ່າ. ຖືກໃຊ້. ຍາກທີ່ຈະດີບັກ ແລະຮັກສາ ດີບັກ ແລະຮັກສາງ່າຍກວ່າ ຜົນໄດ້ຮັບໃນ stack overflow ຖ້າຖານ ບໍ່ໄດ້ລະບຸເງື່ອນໄຂ ຫຼື ບໍ່ໄດ້ບັນລຸ. ອາດຈະປະຕິບັດຢ່າງບໍ່ຢຸດຢັ້ງ ແຕ່ສຸດທ້າຍຈະຢຸດການປະຕິບັດດ້ວຍຄວາມຜິດພາດຂອງຫນ່ວຍຄວາມຈໍາ ຄວາມຊັບຊ້ອນເວລາແມ່ນສູງຫຼາຍ. ຄວາມຊັບຊ້ອນເວລາແມ່ນຂ້ອນຂ້າງຢູ່ຂ້າງລຸ່ມ. ຄຳຖາມທີ່ຖາມເລື້ອຍໆ
ຄຳຖາມ #1) Recursion ເຮັດວຽກແນວໃດໃນ Java?
ຄຳຕອບ: ໃນການເອີ້ນຄືນ, ຟັງຊັນ recursive ເອີ້ນຕົວມັນເອງຊ້ຳໆຈົນກວ່າເງື່ອນໄຂພື້ນຖານຈະພໍໃຈ. ໜ່ວຍຄວາມຈຳສຳລັບຟັງຊັນທີ່ຖືກເອີ້ນນັ້ນຖືກດັນໃສ່ໃສ່ຊຸດຢູ່ເທິງສຸດຂອງໜ່ວຍຄວາມຈຳສຳລັບຟັງຊັນການໂທ. ສຳລັບການເອີ້ນຟັງຊັນແຕ່ລະອັນ, ສຳເນົາຕົວແປຕ່າງທ້ອງຖິ່ນແມ່ນເຮັດ.
ຄຳຖາມ #2) ເປັນຫຍັງໃຊ້ Recursion?
ຄໍາຕອບ: Recursion ຖືກນໍາໃຊ້ເພື່ອແກ້ໄຂບັນຫາເຫຼົ່ານັ້ນທີ່ສາມາດແບ່ງອອກເປັນຂະຫນາດນ້ອຍກວ່າແລະບັນຫາທັງຫມົດສາມາດສະແດງອອກໃນແງ່ຂອງບັນຫາຂະຫນາດນ້ອຍກວ່າ.
Recursion ຍັງຖືກນໍາໃຊ້ສໍາລັບບັນຫາເຫຼົ່ານັ້ນເຊັ່ນດຽວກັນ. ສະລັບສັບຊ້ອນທີ່ຈະໄດ້ຮັບການແກ້ໄຂໂດຍໃຊ້ວິທີການຊ້ໍາກັນ. ນອກຈາກບັນຫາທີ່ຄວາມສັບສົນຂອງເວລາບໍ່ແມ່ນບັນຫາ, ໃຫ້ໃຊ້ recursion.
Q #3) ແມ່ນຫຍັງຄືຜົນປະໂຫຍດຂອງRecursion?
ຄຳຕອບ:
ຜົນປະໂຫຍດຂອງ Recursion ລວມມີ:
- Recursion ຫຼຸດຜ່ອນການໂທຊ້ຳຊ້ອນ ຂອງຟັງຊັນ.
- Recursion ຊ່ວຍໃຫ້ພວກເຮົາແກ້ໄຂບັນຫາໄດ້ງ່າຍເມື່ອປຽບທຽບກັບວິທີການຊໍ້າຄືນ.
ຄຳຖາມ #4) ອັນໃດດີກວ່າ – Recursion ຫຼື Iteration?
ຄຳຕອບ: Recursion ເຮັດການໂທຊ້ຳໆຈົນກວ່າຈະຮອດຟັງຊັນຖານ. ດັ່ງນັ້ນຈຶ່ງມີຫນ່ວຍຄວາມຈໍາຢູ່ເຫນືອຫົວເປັນຫນ່ວຍຄວາມຈໍາສໍາລັບການເອີ້ນຟັງຊັນແຕ່ລະແມ່ນ pushed ໄປ stack. ການປະຕິບັດ Recursion ແມ່ນຊ້າກວ່າວິທີການຊ້ໍາກັນ. Recursion ຫຼຸດຂະໜາດຂອງລະຫັດ ໃນຂະນະທີ່ວິທີການຊໍ້າຄືນເຮັດໃຫ້ລະຫັດມີຂະໜາດໃຫຍ່.
ຄຳຖາມ #5) ຂໍ້ໄດ້ປຽບຂອງ Recursion ຫຼາຍກວ່າ Iteration ແມ່ນຫຍັງ?
ຄຳຕອບ:
- Recursion ເຮັດໃຫ້ລະຫັດຊັດເຈນກວ່າ ແລະສັ້ນກວ່າ.
- Recursion ແມ່ນດີກວ່າວິທີການຊ້ຳກັນສຳລັບບັນຫາເຊັ່ນ: Tower of Hanoi, tree traversals, ແລະອື່ນໆ.
- ເນື່ອງຈາກທຸກໆການເອີ້ນຟັງຊັນມີຄວາມຊົງຈຳຖືກດັນໄປໃສ່ stack, Recursion ຈະໃຊ້ຄວາມຈຳຫຼາຍກວ່າ.
- ປະສິດທິພາບຂອງ Recursion ແມ່ນຊ້າກວ່າວິທີການເຮັດຊ້ຳ.
ສະຫຼຸບ
Recursion ເປັນແນວຄວາມຄິດທີ່ສຳຄັນຫຼາຍໃນຊອບແວ ໂດຍບໍ່ຄຳນຶງເຖິງພາສາການຂຽນໂປຣແກຣມ. Recursion ສ່ວນຫຼາຍແມ່ນໃຊ້ໃນການແກ້ໄຂບັນຫາໂຄງສ້າງຂໍ້ມູນເຊັ່ນ: ຫໍຄອຍຮ່າໂນ້ຍ, ເສັ້ນທາງຜ່ານຕົ້ນໄມ້, ລາຍຊື່ທີ່ເຊື່ອມໂຍງ, ແລະອື່ນໆ.recursion ເຮັດໃຫ້ລະຫັດງ່າຍກວ່າ ແລະຊັດເຈນຂຶ້ນ.
ພວກເຮົາໄດ້ສຳຫຼວດທັງໝົດກ່ຽວກັບ Recursion ໃນບົດຮຽນນີ້. ພວກເຮົາຍັງໄດ້ປະຕິບັດຕົວຢ່າງການຂຽນໂປລແກລມຈໍານວນຫລາຍເພື່ອໃຫ້ຄວາມເຂົ້າໃຈດີຂຶ້ນກ່ຽວກັບແນວຄວາມຄິດ.