ເຈົ້າເຄີຍຖືກຈັບຢູ່ໃນວົງຈອນທີ່ເບິ່ງຄືວ່າບໍ່ສິ້ນສຸດທີ່ບັນຫາເຮັດໃຫ້ສາຂາເປັນຊິ້ນສ່ວນນ້ອຍໆບໍ?
ຖ້າເປັນເຊັ່ນນັ້ນ, ເຈົ້າອາດຈະໄດ້ມາສູ່ໂລກແຫ່ງການເອີ້ນຄືນທີ່ໜ້າຕື່ນເຕັ້ນ. ໃນຂະນະທີ່ມັນອາດຈະເປັນການທ້າທາຍທີ່ຈະເຂົ້າໃຈ, ຢ່າກັງວົນ! ໃນບົດຂຽນນີ້, ພວກເຮົາຈະໄປກ່ຽວກັບການເດີນທາງທີ່ຫນ້າສົນໃຈເພື່ອຮຽນຮູ້ກ່ຽວກັບປະເພດຂອງການເອີ້ນຄືນ.
ດັ່ງນັ້ນ buckle ຂຶ້ນເມື່ອພວກເຮົາສໍາຫຼວດວິທີການ recursive ຈໍານວນຫຼາຍ. ກຽມພ້ອມທີ່ຈະເຂົ້າສູ່ໂລກທີ່ຫນ້າປະທັບໃຈຂອງ recursion ແລະສັງເກດເຫັນຄວາມສາມາດທີ່ໂດດເດັ່ນຂອງມັນໃນການແກ້ໄຂບັນຫາທີ່ສັບສົນ.
Recursions ແມ່ນຫຍັງແທ້?
ໃນຄໍາສັບຕ່າງໆພື້ນຖານ, recursion ແມ່ນເຕັກນິກການຂຽນໂປລແກລມທີ່ມີປະສິດທິພາບທີ່ປະກອບມີຫນ້າທີ່ເອີ້ນຕົວເອງໃນລະຫວ່າງການປະຕິບັດ. ມັນຄ້າຍຄືກັບການເບິ່ງເຂົ້າໄປໃນກະຈົກແລະເຫັນຮູບພາບພາຍໃນຮູບພາບ, ສົ່ງຜົນໃຫ້ວົງຈອນການອ້າງອິງຕົນເອງ.
ພວກເຮົາສາມາດແກ້ໄຂບັນຫາໃຫຍ່ໂດຍການນໍາໃຊ້ recursion ໂດຍການແບ່ງອອກເປັນບັນຫາຍ່ອຍຂະຫນາດນ້ອຍແລະການຄຸ້ມຄອງຫຼາຍກວ່າ.
ມັນຄ້າຍຄືກັບການວາງ jigsaw ຮ່ວມກັນ, ບ່ອນທີ່ສິ້ນຫນຶ່ງເຊື່ອມຕໍ່ກັບພາກສ່ວນອື່ນໆເພື່ອຜະລິດຮູບພາບເຕັມ. Recursion ອະນຸຍາດໃຫ້ພວກເຮົາແກ້ໄຂບັນຫາໃນລັກສະນະທີ່ສະຫງ່າງາມແລະມີປະສິດທິພາບໂດຍການເຮັດຊ້ໍາຄໍາແນະນໍາດຽວກັນກັບວັດສະດຸປ້ອນຕ່າງໆ.
1-Recursion ໂດຍກົງ
recursion ໂດຍກົງແມ່ນປະເພດພື້ນຖານທີ່ສຸດຂອງ recursion, ໃນຫນ້າທີ່ເອີ້ນຕົວເອງໂດຍກົງ. ມັນປະກອບມີການແບ່ງບັນຫາທີ່ເປັນບັນຫາອອກເປັນບັນຫາຍ່ອຍເລັກນ້ອຍຈົນກ່ວາກໍລະນີພື້ນຖານບັນລຸໄດ້, ເຊິ່ງນໍາໄປສູ່ການຢຸດເຊົາ.
ຟັງຊັນ recursive ເອີ້ນຕົວມັນເອງດ້ວຍວັດສະດຸປ້ອນຕ່າງໆ, ເຮັດໃຫ້ການປະຕິບັດຄໍາແນະນໍາຊຸດດຽວກັນຊ້ໍາກັນ. ການຮຽກຮ້ອງແຕ່ລະອັນສ້າງຂື້ນຢູ່ກັບອັນກ່ອນໜ້າ, ກ້າວໄປໃກ້ກໍລະນີຖານທີ່ເຮັດໃຫ້ເກີດການເອີ້ນຄືນອີກຄັ້ງ.
ໃຫ້ກວດເບິ່ງຕົວຢ່າງນີ້.
def countdown(n):
if n <= 0:
return
print(n)
countdown(n - 1)
countdown(5)
ຜົນໄດ້ຮັບ:
5
4
3
2
1
2-ການເອີ້ນຄືນທາງອ້ອມ
recursion ທາງອ້ອມເພີ້ມການບິດ intriguing ກັບເສັ້ນທາງ recursive. ໃນທາງກົງກັນຂ້າມກັບ recursion ໂດຍກົງ, ເຊິ່ງກ່ຽວຂ້ອງກັບຫນ້າທີ່ເອີ້ນຕົວມັນເອງຢ່າງຊັດເຈນ, recursion ໂດຍທາງອ້ອມປະກອບມີລະບົບຕ່ອງໂສ້ການເອີ້ນຟັງຊັນ.
ຟັງຊັນຫນຶ່ງເອີ້ນອີກອັນຫນຶ່ງ, ເຊິ່ງຫຼັງຈາກນັ້ນສາມາດເອີ້ນຟັງຊັນຕົ້ນສະບັບຫຼືຟັງຊັນອື່ນໆທີ່ສຸດທ້າຍກັບຄືນສູ່ຕົ້ນສະບັບ. ໜ້າທີ່ເຊື່ອມຕໍ່ກັນໃນເວັບນີ້ເຮັດໃຫ້ເກີດການເຕັ້ນທີ່ໜ້າຕື່ນເຕັ້ນ ເຊິ່ງຫຼາຍໜ້າທີ່ຮ່ວມມືກັນເພື່ອແກ້ໄຂບັນຫາ.
ຕົວຢ່າງ:
def function_A(n):
if n > 0:
print("A:", n)
function_B(n - 1)
def function_B(n):
if n > 0:
print("B:", n)
function_A(n - 1)
function_A(3)
ຜົນໄດ້ຮັບ:
A: 3
B: 2
A: 1
3-Linear Recursion
ພິຈາລະນາການເດີນທາງໃນເສັ້ນທາງຊື່, ຫນຶ່ງບາດກ້າວຕໍ່ເວລາ, ຈົນກ່ວາທ່ານໄປຮອດຈຸດປະສົງຂອງທ່ານ. ເທກນິກຕາມລໍາດັບນີ້ແມ່ນຖືກລວມເຂົ້າກັນໂດຍການເອີ້ນຄືນແບບເສັ້ນຊື່, ເຊິ່ງຟັງຊັນໜຶ່ງເຮັດການເອີ້ນຊ້ຳຄືນດຽວໃນແຕ່ລະຟັງຊັນ.
ດ້ວຍແຕ່ລະການໂທ recursive, ຂະບວນການ recursive ເຄື່ອນຍ້າຍໄປໃກ້ກັບກໍລະນີພື້ນຖານໂດຍການຫຼຸດຂະຫນາດຂອງບັນຫາ. ມັນດໍາເນີນໄປໃນລັກສະນະທີ່ຊັດເຈນແລະເປັນເສັ້ນ, ແກ້ໄຂບັນຫາຍ່ອຍໃນແຕ່ລະຄັ້ງຈົນກ່ວາຄໍາຕອບສຸດທ້າຍຈະບັນລຸໄດ້.
ຕົວຢ່າງ:
def factorial(n):
if n == 0:
return 1
return n * factorial(n - 1)
result = factorial(5)
print(result)
ຜົນໄດ້ຮັບ:
120
4-Recursion ຕົ້ນໄມ້
ເມື່ອຟັງຊັນສາຂາເຂົ້າໄປໃນການໂທ recursive ຫຼາຍ, ພວກເຮົາເຂົ້າສູ່ໂລກຂອງຕົ້ນໄມ້ recursion. ຟັງຊັນນຶ່ງໃນ recursion ຕົ້ນໄມ້ສ້າງການໂທ recursive ຫຼາຍ, ແຕ່ລະຄົນແກ້ໄຂບັນຫາຍ່ອຍແຍກຕ່າງຫາກ, ຄືກັນກັບສາຂາຂອງຕົ້ນໄມ້ເຮັດ.
ໂຄງສ້າງສາຂານີ້ອະນຸຍາດໃຫ້ມີການສືບສວນພ້ອມກັນຂອງຫຼາຍເສັ້ນທາງ, ແຍກບັນຫາທີ່ສັບສົນອອກເປັນອົງປະກອບຂະຫນາດນ້ອຍ, ທີ່ກ່ຽວຂ້ອງຢ່າງມີປະສິດທິຜົນ.
ຕົວຢ່າງ:
def fibonacci(n):
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
result = fibonacci(6)
print(result)
ຜົນໄດ້ຮັບ:
8
5- Nested Recursion
Nested recursion ເພີ່ມລະດັບຄວາມຊັບຊ້ອນທີ່ຫນ້າຕື່ນເຕັ້ນໃຫ້ກັບຈັກກະວານ recursive. ໃນຮູບແບບຂອງ recursion ນີ້, ຟັງຊັນລວມເອົາການໂທ recursive ເປັນການໂຕ້ຖຽງພາຍໃນການໂທ recursive ອື່ນ.
ການໂທ recursive ພາຍໃນປະຕິບັດກັບມູນຄ່າທີ່ຂຶ້ນກັບການໂທ recursive ພາຍນອກ. ຄວາມຊັບຊ້ອນຈະເລີນເຕີບໂຕຂຶ້ນດ້ວຍແຕ່ລະຄຳຮຽກຮ້ອງທີ່ຊ້ອນກັນ, ສິ້ນສຸດດ້ວຍຮູບແບບທີ່ໜ້າສົນໃຈຂອງການໂທຊ້ຳຊ້ອນກັນ.
ຕົວຢ່າງ:
def nested_recursion(n):
if n > 100:
return n - 10
return nested_recursion(nested_recursion(n + 11))
result = nested_recursion(95)
print(result)
ຜົນໄດ້ຮັບ:
91
6-ຫາງ Recursion
Tail recursion ແມ່ນເຕັກນິກການເພີ່ມປະສິດທິພາບສໍາລັບ algorithms recursive ທີ່ສາມາດປັບປຸງປະສິດທິພາບຂອງເຂົາເຈົ້າ. ການໂທ recursive ປະກົດວ່າເປັນການປະຕິບັດສຸດທ້າຍຂອງຫນ້າທີ່ທີ່ມີຫາງ recursion, ເຮັດໃຫ້.
ເນື່ອງຈາກວ່າບໍ່ມີການດໍາເນີນການທີ່ຍັງຄ້າງຄາປະຕິບັດຕາມການໂທ recursive, compiler ຫຼືນາຍພາສາສາມາດເຮັດໃຫ້ recursion ງ່າຍດາຍໂດຍການປ່ຽນແທນມັນດ້ວຍການກະໂດດງ່າຍດາຍ.
ວິທີການເພີ່ມປະສິດທິພາບນີ້, ເອີ້ນວ່າການເພີ່ມປະສິດທິພາບການໂທຫາງ, ຫຼຸດຜ່ອນຄວາມຕ້ອງການຂອງແຕ່ລະການໂທ recursive ເພື່ອຮັກສາກອບ stack, ສົ່ງຜົນໃຫ້ຄວາມໄວທີ່ເພີ່ມຂຶ້ນແລະການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາຕ່ໍາ.
ຕົວຢ່າງ:
def tail_factorial(n, result=1):
if n == 0:
return result
return tail_factorial(n - 1, result * n)
result = tail_factorial(5)
print(result)
ອອກນອກ:
120
7- ບໍ່ຫາງ
ກົງກັນຂ້າມກັບ recursion ຫາງ, ການ recursion ທີ່ບໍ່ແມ່ນຫາງກ່ຽວຂ້ອງກັບກິດຈະກໍາພິເສດທີ່ປະຕິບັດຫຼັງຈາກການໂທຫາ recursive ພາຍໃນຫນ້າທີ່ໃດຫນຶ່ງ. ກ່ອນທີ່ຈະດໍາເນີນການໃດໆເພີ່ມເຕີມ, ແຕ່ລະການໂທ recursive ຈະຕ້ອງສໍາເລັດແລະກັບຄືນ.
ດັ່ງນັ້ນ, ຈົນກ່ວາກໍລະນີພື້ນຖານແມ່ນບັນລຸໄດ້ແລະ recursion ສິ້ນສຸດລົງ, stack ຂອງການດໍາເນີນງານທີ່ຍັງຄ້າງຄາຖືກຮັກສາໄວ້. ການເອີ້ນຄືນແບບບໍ່ມີຫາງມັກຈະໃຊ້ຄວາມຊົງຈໍາຫຼາຍກວ່າ ແລະມີປະສິດທິພາບໜ້ອຍກວ່າການເອີ້ນຄືນຫາງ, ແຕ່ມັນຍັງເປັນເຄື່ອງມືທີ່ເປັນປະໂຫຍດສໍາລັບການແກ້ໄຂບັນຫາຕ່າງໆ.
ຕົວຢ່າງ:
def non_tail_sum(n):
if n == 0:
return 0
return n + non_tail_sum(n - 1)
result = non_tail_sum(5)
print(result)
ຜົນໄດ້ຮັບ:
15
ສະຫຼຸບ
Recursion ເປັນແນວຄວາມຄິດທີ່ຫນ້າສົນໃຈໃນການຂຽນໂປຼແກຼມ. ມັນອະນຸຍາດໃຫ້ພວກເຮົາແກ້ໄຂບັນຫາທີ່ສັບສົນໃນລັກສະນະການອ້າງອິງຕົນເອງແບບ recursive.
ມັນສະເໜີວິທີການຄິດ ແລະແກ້ໄຂບັນຫາທີ່ແຕກຕ່າງ, ແຍກພວກມັນອອກເປັນຕ່ອນນ້ອຍໆ, ສາມາດຈັດການໄດ້ຫຼາຍຂຶ້ນ. ໃນເວລາທີ່ເຮັດວຽກກັບ recursion, ຢ່າງໃດກໍຕາມ, ມັນເປັນສິ່ງສໍາຄັນທີ່ຈະນໍາໃຊ້ເອົາໃຈໃສ່ກັບບາງຈຸດ.
ທ່ານຄວນກໍານົດກໍລະນີພື້ນຖານທີ່ເຫມາະສົມທີ່ອະນຸຍາດໃຫ້ recursion ສິ້ນສຸດລົງ. ຖ້າພວກເຂົາບໍ່ຢູ່, ຫນ້າທີ່ອາດຈະສືບຕໍ່ເອີ້ນຕົວເອງຕະຫຼອດໄປ.
ອັນທີສອງ, ໂດຍອີງໃສ່ສະຖານະການຢູ່ໃນມື, ການເລືອກປະເພດທີ່ເຫມາະສົມຂອງ recursion ສາມາດນໍາໄປສູ່ການແກ້ໄຂທີ່ມີປະສິດທິພາບແລະສະຫງ່າງາມ. ພະຍາຍາມຊອກຫາສິ່ງທີ່ເຮັດວຽກທີ່ດີທີ່ສຸດສໍາລັບບັນຫາຢູ່ໃນມື. ເມື່ອເຮັດວຽກກັບຄວາມເລິກ recursion ທີ່ກວ້າງຂວາງ, ຈົ່ງລະວັງໄພອັນຕະລາຍທີ່ອາດຈະເກີດຂຶ້ນເຊັ່ນ stack overflow.
ອອກຈາກ Reply ເປັນ