ความแตกต่างระหว่างการเรียกซ้ำและการวนซ้ำ

2019

การเรียกซ้ำและการวนซ้ำทั้งสองครั้งจะดำเนินการชุดคำสั่ง การเรียกซ้ำคือเมื่อคำสั่งในฟังก์ชันเรียกตัวเองซ้ำ ๆ การวนซ้ำคือเมื่อวนซ้ำดำเนินการจนกว่าเงื่อนไขการควบคุมจะกลายเป็นเท็จ ความแตกต่างหลักระหว่างการเรียกซ้ำและการวนซ้ำคือการ เรียกซ้ำ เป็นกระบวนการที่ใช้กับฟังก์ชันเสมอ การ วนซ้ำ นั้นใช้กับชุดคำสั่งที่เราต้องการเรียกใช้ซ้ำหลายครั้ง

แผนภูมิเปรียบเทียบ

พื้นฐานสำหรับการเปรียบเทียบ	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 ของตัวเลขโดยใช้คำสั่งการวนซ้ำ