ความแตกต่างที่สำคัญ – การเรียกซ้ำกับการวนซ้ำ
การเรียกซ้ำและการวนซ้ำสามารถใช้เพื่อแก้ปัญหาการเขียนโปรแกรมได้ แนวทางในการแก้ปัญหาโดยใช้การเรียกซ้ำหรือการวนซ้ำนั้นขึ้นอยู่กับวิธีการแก้ปัญหา ความแตกต่างที่สำคัญระหว่างการเรียกซ้ำและการวนซ้ำคือการเรียกซ้ำเป็นกลไกในการเรียกใช้ฟังก์ชันภายในฟังก์ชันเดียวกัน ในขณะที่การวนซ้ำคือการดำเนินการชุดคำสั่งซ้ำๆ จนกว่าเงื่อนไขที่กำหนดจะเป็นจริง การเรียกซ้ำและการวนซ้ำเป็นเทคนิคหลักในการพัฒนาอัลกอริทึมและการสร้างแอปพลิเคชันซอฟต์แวร์
การเรียกซ้ำคืออะไร
เมื่อฟังก์ชันเรียกตัวเองภายในฟังก์ชัน จะเรียกว่าการเรียกซ้ำ การเรียกซ้ำมีสองประเภท เป็นการเรียกซ้ำแบบจำกัดและการเรียกซ้ำแบบไม่จำกัด การเรียกซ้ำแบบจำกัดมีเงื่อนไขที่สิ้นสุด การเรียกซ้ำแบบไม่มีที่สิ้นสุดไม่มีเงื่อนไขการสิ้นสุด
การเรียกซ้ำสามารถอธิบายได้โดยใช้โปรแกรมคำนวณแฟคทอเรียล
n!=n(n-1)! ถ้า n>0
n!=1 ถ้า n=0;
ดูโค้ดด้านล่างเพื่อคำนวณแฟคทอเรียลของ 3(3!=321)
intmain () {
ค่า int=factorial (3);
printf(“แฟคทอเรียลคือ %d\n” ค่า);
คืน 0;
}
intfactorial (intn) {
ถ้า(n==0) {
คืน 1;
}
อื่น {
ผลตอบแทน n แฟคทอเรียล(n-1);
}
}
เมื่อเรียกแฟคทอเรียล (3) ฟังก์ชันนั้นจะเรียกแฟคทอเรียล (2) เมื่อเรียกแฟกทอเรียล (2) ฟังก์ชันนั้นจะเรียกแฟกทอเรียล (1) จากนั้นแฟกทอเรียล (1) จะเรียกแฟคทอเรียล (0) แฟกทอเรียล (0) จะคืนค่า 1. ในโปรแกรมข้างต้น เงื่อนไข n==0 ใน “if block” เป็นเงื่อนไขพื้นฐานในทำนองเดียวกัน ฟังก์ชันแฟกทอเรียลจะถูกเรียกซ้ำแล้วซ้ำเล่า
ฟังก์ชันแบบเรียกซ้ำเกี่ยวข้องกับสแต็ก ใน C โปรแกรมหลักสามารถมีได้หลายฟังก์ชัน ดังนั้น main () คือฟังก์ชันการเรียก และฟังก์ชันที่เรียกโดยโปรแกรมหลักคือฟังก์ชันที่เรียกว่า เมื่อเรียกใช้ฟังก์ชัน ตัวควบคุมจะกำหนดให้กับฟังก์ชันที่เรียก หลังจากดำเนินการฟังก์ชันเสร็จสิ้น ตัวควบคุมจะกลับสู่หลัก จากนั้นโปรแกรมหลักจะดำเนินต่อไป ดังนั้นจึงสร้างบันทึกการเปิดใช้งานหรือสแต็กเฟรมเพื่อดำเนินการต่อไป
รูปที่ 01: การเรียกซ้ำ
ในโปรแกรมด้านบน เมื่อเรียก factorial (3) จาก main จะสร้างบันทึกการเปิดใช้งานใน call stack จากนั้นสร้างเฟรมสแต็กแฟคทอเรียล (2) ที่ด้านบนของสแต็กเป็นต้น บันทึกการเปิดใช้งานจะเก็บข้อมูลเกี่ยวกับตัวแปรในเครื่อง ฯลฯ ทุกครั้งที่มีการเรียกใช้ฟังก์ชัน จะมีการสร้างตัวแปรภายในชุดใหม่ที่ด้านบนของสแต็ก สแต็กเฟรมเหล่านี้สามารถชะลอความเร็วได้ ในทำนองเดียวกันในการเรียกซ้ำ ฟังก์ชันจะเรียกตัวเอง ความซับซ้อนของเวลาสำหรับฟังก์ชันแบบเรียกซ้ำนั้นหาได้จากจำนวนครั้งที่เรียกใช้ฟังก์ชัน ความซับซ้อนของเวลาสำหรับการเรียกใช้ฟังก์ชันหนึ่งครั้งคือ O(1) สำหรับจำนวนการโทรซ้ำ ความซับซ้อนของเวลาคือ O(n)
การวนซ้ำคืออะไร
Iteration เป็นบล็อกของคำสั่งที่ทำซ้ำซ้ำแล้วซ้ำอีกจนกว่าเงื่อนไขที่กำหนดจะเป็นจริง การวนซ้ำสามารถทำได้โดยใช้ "for loop", "do-while loop" หรือ "while loop" ไวยากรณ์ “for loop” มีดังต่อไปนี้
for (เริ่มต้น; เงื่อนไข; แก้ไข) {
// งบ;
}
รูปที่ 02: “สำหรับแผนภาพการไหลวน”
ขั้นตอนการเริ่มต้นดำเนินการก่อน ขั้นตอนนี้คือการประกาศและเริ่มต้นตัวแปรควบคุมลูป หากเงื่อนไขเป็นจริง คำสั่งในวงเล็บปีกกาจะดำเนินการ คำสั่งเหล่านั้นดำเนินการจนกว่าเงื่อนไขจะเป็นจริง หากเงื่อนไขเป็นเท็จ ตัวควบคุมจะไปที่คำสั่งถัดไปหลังจาก "for loop" หลังจากรันคำสั่งภายในลูปแล้ว ตัวควบคุมจะไปที่ส่วนแก้ไข เป็นการอัพเดทตัวแปรควบคุมลูป จากนั้นตรวจสอบเงื่อนไขอีกครั้งหากเงื่อนไขเป็นจริง คำสั่งในวงเล็บปีกกาจะดำเนินการ วิธีนี้จะทำให้ “for loop” วนซ้ำ
ใน “while loop” คำสั่งภายในลูปจะดำเนินการจนกว่าเงื่อนไขจะเป็นจริง
ในขณะที่ (เงื่อนไข){
//statements
}
ในลูป “do-while” เงื่อนไขจะถูกตรวจสอบที่ส่วนท้ายของลูป ดังนั้น การวนซ้ำจะดำเนินการอย่างน้อยหนึ่งครั้ง
ทำ{
//statements
} ในขณะที่(เงื่อนไข)
โปรแกรมหาแฟกทอเรียลของ 3 (3!) โดยใช้การวนซ้ำ (“for loop”) มีดังนี้
int หลัก(){
intn=3, แฟคทอเรียล=1;
inti;
for(i=1; i<=n; i++){
factorial=แฟคทอเรียลi;
}
printf(“แฟกทอเรียลคือ %d\n”, แฟกทอเรียล);
คืน 0;
}
ความคล้ายคลึงกันระหว่างการเรียกซ้ำและการวนซ้ำคืออะไร
- ทั้งสองเป็นเทคนิคในการแก้ปัญหา
- งานสามารถแก้ไขได้ทั้งแบบเรียกซ้ำหรือวนซ้ำ
การเรียกซ้ำและการวนซ้ำต่างกันอย่างไร
การเรียกซ้ำกับการวนซ้ำ |
|
| การเรียกซ้ำคือวิธีการเรียกฟังก์ชันภายในฟังก์ชันเดียวกัน | การวนซ้ำคือบล็อกของคำสั่งที่ทำซ้ำจนกว่าเงื่อนไขที่กำหนดจะเป็นจริง |
| ความซับซ้อนของอวกาศ | |
| ความซับซ้อนของพื้นที่ของโปรแกรมแบบเรียกซ้ำนั้นสูงกว่าการวนซ้ำ | ความซับซ้อนของพื้นที่มีการวนซ้ำต่ำกว่า |
| ความเร็ว | |
| การเรียกซ้ำช้า | โดยปกติ การวนซ้ำจะเร็วกว่าการเรียกซ้ำ |
| สภาพ | |
| หากไม่มีเงื่อนไขการสิ้นสุด อาจมีการเรียกซ้ำที่ไม่สิ้นสุด | ถ้าเงื่อนไขไม่เคยกลายเป็นเท็จ มันจะเป็นการวนซ้ำที่ไม่สิ้นสุด |
| กอง | |
| ในการเรียกซ้ำ สแต็กถูกใช้เพื่อเก็บตัวแปรในเครื่องเมื่อมีการเรียกใช้ฟังก์ชัน | ในการวนซ้ำ สแต็กจะไม่ถูกใช้ |
| การอ่านโค้ด | |
| โปรแกรมแบบเรียกซ้ำอ่านง่ายขึ้น | โปรแกรมแบบวนซ้ำนั้นอ่านยากกว่าโปรแกรมแบบเรียกซ้ำ |
สรุป – การเรียกซ้ำกับการวนซ้ำ
บทความนี้กล่าวถึงความแตกต่างระหว่างการเรียกซ้ำและการวนซ้ำทั้งสองสามารถใช้เพื่อแก้ปัญหาการเขียนโปรแกรม ความแตกต่างระหว่างการเรียกซ้ำและการวนซ้ำคือการเรียกซ้ำเป็นกลไกในการเรียกใช้ฟังก์ชันภายในฟังก์ชันเดียวกันและทำซ้ำเพื่อดำเนินการชุดคำสั่งซ้ำๆ จนกว่าเงื่อนไขที่กำหนดจะเป็นจริง หากปัญหาสามารถแก้ไขได้ในรูปแบบเรียกซ้ำ ก็สามารถแก้ไขได้โดยใช้การวนซ้ำ
ดาวน์โหลด Recursion vs Iteration เวอร์ชัน PDF
คุณสามารถดาวน์โหลดไฟล์ PDF ของบทความนี้และใช้เพื่อวัตถุประสงค์ออฟไลน์ตามหมายเหตุอ้างอิง โปรดดาวน์โหลดไฟล์ PDF ที่นี่ ความแตกต่างระหว่างการเรียกซ้ำและการวนซ้ำ