ความแตกต่างระหว่างการเรียกซ้ำและการวนซ้ำ
เนื้อหา
การเรียกซ้ำและการวนซ้ำทั้งสองครั้งจะดำเนินการชุดคำสั่ง การเรียกซ้ำคือเมื่อคำสั่งในฟังก์ชันเรียกตัวเองซ้ำ ๆ การวนซ้ำคือเมื่อวนซ้ำดำเนินการจนกระทั่งเงื่อนไขการควบคุมกลายเป็นเท็จ ความแตกต่างหลักระหว่างการเรียกซ้ำและการทำซ้ำคือ เรียกซ้ำ เป็นกระบวนการที่ใช้กับฟังก์ชั่นเสมอ การย้ำ ถูกนำไปใช้กับชุดคำสั่งที่เราต้องการเรียกใช้ซ้ำหลายครั้ง
- แผนภูมิเปรียบเทียบ
- คำนิยาม
- ความแตกต่างที่สำคัญ
- ข้อสรุป
แผนภูมิเปรียบเทียบ
| พื้นฐานสำหรับการเปรียบเทียบ | recursion | การย้ำ |
|---|---|---|
| ขั้นพื้นฐาน | คำสั่งในเนื้อหาของฟังก์ชันเรียกใช้ฟังก์ชันเอง | อนุญาตให้ชุดคำสั่งดำเนินการซ้ำหลายครั้ง |
| รูป | ในฟังก์ชั่นแบบเรียกซ้ำจะระบุเฉพาะเงื่อนไขการเลิกจ้าง (กรณีฐาน) | การวนซ้ำรวมถึงการกำหนดค่าเริ่มต้น, เงื่อนไข, การดำเนินการของคำสั่งภายในลูปและอัพเดต (การเพิ่มขึ้นและลดลง) ตัวแปรควบคุม |
| การสิ้นสุด | คำสั่งแบบมีเงื่อนไขจะรวมอยู่ในเนื้อหาของฟังก์ชันเพื่อบังคับให้ฟังก์ชันส่งคืนโดยไม่ต้องเรียกใช้การเรียกซ้ำ | คำสั่งการทำซ้ำจะดำเนินการซ้ำ ๆ จนกว่าจะถึงเงื่อนไขที่แน่นอน |
| เงื่อนไข | หากฟังก์ชั่นไม่ได้มาบรรจบกับเงื่อนไขบางอย่างที่เรียกว่า (เคสฐาน) มันจะนำไปสู่การเรียกซ้ำแบบไม่สิ้นสุด | หากเงื่อนไขการควบคุมในคำสั่งการทำซ้ำไม่เป็นเท็จจะนำไปสู่การทำซ้ำไม่สิ้นสุด |
| การทำซ้ำไม่สิ้นสุด | การเรียกซ้ำไม่สิ้นสุดอาจทำให้ระบบขัดข้อง | วงวนไม่สิ้นสุดใช้วัฏจักร CPU ซ้ำ ๆ |
| ประยุกต์ | การเรียกซ้ำถูกนำไปใช้กับฟังก์ชันเสมอ | การทำซ้ำถูกนำไปใช้กับคำสั่งการทำซ้ำหรือ "ลูป" |
| กอง | สแต็กใช้เพื่อจัดเก็บชุดของตัวแปรและพารามิเตอร์ใหม่ ๆ ในแต่ละครั้งที่เรียกใช้ฟังก์ชัน | ไม่ใช้สแต็ก |
| เหนือศีรษะ | การเรียกซ้ำมีโอเวอร์เฮดของการเรียกฟังก์ชันซ้ำ | ไม่มีค่าใช้จ่ายในการเรียกใช้ฟังก์ชันซ้ำ |
| ความเร็ว | ช้าในการดำเนินการ | ดำเนินการอย่างรวดเร็ว |
| ขนาดของรหัส | การเรียกซ้ำลดขนาดของรหัส | การวนซ้ำทำให้โค้ดยาวขึ้น |
คำจำกัดความของการเรียกซ้ำ
C ++ อนุญาตให้ฟังก์ชันเรียกใช้ตัวเองภายในรหัส นั่นหมายถึงความหมายของฟังก์ชั่นที่มีฟังก์ชั่นการโทรไปยังตัวเอง บางครั้งเรียกว่า“ความหมายวงกลม“ ชุดของตัวแปรท้องถิ่นและพารามิเตอร์ที่ใช้โดยฟังก์ชั่นที่สร้างขึ้นใหม่ทุกครั้งที่ฟังก์ชั่นเรียกตัวเองและจะถูกเก็บไว้ที่ด้านบนของสแต็ค แต่ทุกครั้งที่ฟังก์ชั่นเรียกใช้มันจะไม่สร้างสำเนาใหม่ของฟังก์ชั่นนั้น ฟังก์ชันเรียกซ้ำไม่ลดขนาดของรหัสอย่างมากและไม่ได้ปรับปรุงการใช้งานหน่วยความจำอย่างมีนัยสำคัญ แต่จะทำบางอย่างเมื่อเทียบกับการทำซ้ำ
ในการยกเลิกการเรียกซ้ำคุณต้องรวมคำสั่ง select ในคำจำกัดความของฟังก์ชันเพื่อบังคับให้ฟังก์ชันส่งคืนโดยไม่ต้องเรียกซ้ำแบบเรียกซ้ำ การไม่มีคำสั่ง select ในคำจำกัดความของฟังก์ชั่นวนซ้ำจะช่วยให้ฟังก์ชั่นในการเรียกซ้ำแบบไม่มีที่สิ้นสุดเมื่อถูกเรียก
ให้เราเข้าใจการเรียกซ้ำด้วยฟังก์ชันที่จะคืนค่าแฟกทอเรียลของจำนวนนั้น
int แฟคทอเรียล (int NUM) {คำตอบ int; if (num == 1) {return 1; } else {answer = factorial (NUM-1) * NUM; // recursive call} return (คำตอบ); }
ในโค้ดด้านบนคำสั่งในส่วนอื่นจะแสดงการเรียกซ้ำเนื่องจากคำสั่งเรียกใช้ฟังก์ชัน factorial () ซึ่งมันอยู่
ความหมายของการพูดซ้ำ
การวนซ้ำเป็นกระบวนการของการดำเนินการชุดคำสั่งซ้ำ ๆ จนกระทั่งเงื่อนไขในคำสั่งการวนซ้ำกลายเป็นเท็จ คำสั่งการทำซ้ำรวมถึงการเริ่มต้นการเปรียบเทียบการดำเนินการของคำสั่งภายในคำสั่งการทำซ้ำและในที่สุดการปรับปรุงของตัวแปรควบคุม หลังจากอัพเดตตัวแปรควบคุมแล้วมันจะถูกเปรียบเทียบอีกครั้งและกระบวนการทำซ้ำตัวเองจนกระทั่งเงื่อนไขในคำสั่งการวนซ้ำกลายเป็นเท็จ คำสั่งวนซ้ำเป็น "for" loop, "while" loop, "do-while" loop
คำสั่งการวนซ้ำไม่ได้ใช้สแต็กเพื่อเก็บตัวแปร ดังนั้นการประมวลผลคำสั่งการวนซ้ำจึงเร็วขึ้นเมื่อเทียบกับฟังก์ชันแบบเรียกซ้ำ แม้แต่ฟังก์ชั่นวนซ้ำก็ไม่มีค่าใช้จ่ายในการเรียกฟังก์ชั่นซ้ำซึ่งทำให้การดำเนินการเร็วกว่าฟังก์ชั่นวนซ้ำ การวนซ้ำจะสิ้นสุดลงเมื่อเงื่อนไขการควบคุมเป็นเท็จ การไม่มีเงื่อนไขการควบคุมในคำสั่งการวนซ้ำอาจส่งผลให้เกิดการวนซ้ำไม่สิ้นสุดหรืออาจทำให้เกิดข้อผิดพลาดในการรวบรวม
มาทำความเข้าใจกับการวนซ้ำตามตัวอย่างข้างต้น
int แฟคทอเรียล (int NUM) {คำตอบ int = 1; // ต้องการการเริ่มต้นเนื่องจากอาจมีค่าขยะก่อนการเริ่มต้นสำหรับ (int t = 1; t> num; t ++) // การวนซ้ำ {answer = answer * (t); กลับ (คำตอบ); }}
ในโค้ดด้านบนฟังก์ชันจะคืนค่า factorial ของตัวเลขโดยใช้คำสั่งการวนซ้ำ
- การเรียกซ้ำคือเมื่อเมธอดในโปรแกรมเรียกตัวเองซ้ำ ๆ ในขณะที่การวนซ้ำคือเมื่อชุดคำสั่งในโปรแกรมถูกเรียกใช้ซ้ำ ๆ
- วิธีการเรียกซ้ำมีชุดคำสั่งเรียกใช้คำสั่งเองและเงื่อนไขการเลิกจ้างส่วนคำสั่งการวนซ้ำประกอบด้วยการเริ่มต้นการเพิ่มเงื่อนไขชุดคำสั่งภายในลูปและตัวแปรควบคุม
- คำสั่งแบบมีเงื่อนไขจะตัดสินใจว่าจะยกเลิกการเรียกซ้ำและการควบคุมค่าของตัวแปรซึ่งตัดสินใจว่าจะยกเลิกคำสั่งการทำซ้ำ
- หากวิธีการไม่นำไปสู่เงื่อนไขการเลิกจ้างมันจะเข้าสู่การเรียกซ้ำแบบไม่สิ้นสุด ในทางกลับกันหากตัวแปรควบคุมไม่นำไปสู่ค่าการเลิกจ้างคำสั่งการวนซ้ำจะวนซ้ำอย่างไม่สิ้นสุด
- การเรียกซ้ำแบบไม่สิ้นสุดสามารถนำไปสู่ความล้มเหลวของระบบในขณะที่การทำซ้ำแบบไม่สิ้นสุดจะใช้รอบของ CPU
- การเรียกซ้ำจะใช้กับเมธอดเสมอโดยจะใช้การวนซ้ำกับชุดของคำสั่ง
- ตัวแปรที่สร้างขึ้นในระหว่างการเรียกซ้ำถูกเก็บไว้ในสแต็ก แต่การวนซ้ำไม่ต้องการสแต็ก
- การเรียกซ้ำทำให้เกิดโอเวอร์เฮดของการเรียกฟังก์ชันซ้ำในขณะที่การวนซ้ำไม่มีฟังก์ชันการเรียกใช้โอเวอร์เฮด
- เนื่องจากฟังก์ชั่นการเรียกใช้การดำเนินการเรียกซ้ำซ้อนของการเรียกซ้ำนั้นช้าลงในขณะที่การดำเนินการซ้ำจะเร็วกว่า
- การเรียกซ้ำลดขนาดของรหัสในขณะที่การวนซ้ำทำให้รหัสยาวขึ้น
สรุป:
ฟังก์ชั่นเรียกซ้ำนั้นง่ายต่อการเขียน แต่มันทำงานได้ไม่ดีเมื่อเทียบกับการทำซ้ำในขณะที่การทำซ้ำนั้นยากที่จะเขียน แต่ประสิทธิภาพการทำงานนั้นดีเมื่อเทียบกับการเรียกซ้ำ
