แนะนำ, 2024

ตัวเลือกของบรรณาธิการ

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

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

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

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

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

  1. การเรียกซ้ำคือเมื่อเมธอดในโปรแกรมเรียกตัวเองซ้ำ ๆ ในขณะที่การวนซ้ำคือเมื่อชุดคำสั่งในโปรแกรมนั้นถูกดำเนินการซ้ำ ๆ
  2. วิธีการเรียกซ้ำมีชุดคำสั่งเรียกใช้คำสั่งเองและเงื่อนไขการเลิกจ้างส่วนคำสั่งการวนซ้ำประกอบด้วยการเริ่มต้นการเพิ่มเงื่อนไขชุดคำสั่งภายในลูปและตัวแปรควบคุม
  3. คำสั่งแบบมีเงื่อนไขจะตัดสินการยกเลิกการเรียกซ้ำและการควบคุมค่าของตัวแปรตัดสินใจการสิ้นสุดของคำสั่งการวนซ้ำ
  4. หากวิธีการไม่นำไปสู่เงื่อนไขการเลิกจ้างมันจะเข้าสู่การเรียกซ้ำแบบไม่สิ้นสุด ในทางกลับกันหากตัวแปรควบคุมไม่นำไปสู่ค่าการเลิกจ้างคำสั่งการวนซ้ำจะวนซ้ำอย่างไม่สิ้นสุด
  5. การเรียกซ้ำแบบไม่สิ้นสุดสามารถนำไปสู่ความล้มเหลวของระบบในขณะที่การทำซ้ำแบบไม่สิ้นสุดจะใช้รอบของ CPU
  6. การเรียกซ้ำจะใช้กับเมธอดเสมอโดยจะใช้การวนซ้ำกับชุดของการเรียนการสอน
  7. ตัวแปรที่สร้างขึ้นในระหว่างการเรียกซ้ำถูกเก็บไว้ในสแต็กในขณะที่การวนซ้ำไม่ต้องการสแต็ก
  8. การเรียกซ้ำทำให้เกิดโอเวอร์เฮดของการเรียกใช้ฟังก์ชันซ้ำในขณะที่การวนซ้ำไม่มีฟังก์ชันที่เรียกใช้โอเวอร์เฮด
  9. เนื่องจากฟังก์ชั่นการเรียกใช้การดำเนินการเรียกซ้ำซ้อนของการเรียกซ้ำนั้นช้าลงในขณะที่การดำเนินการซ้ำจะเร็วกว่า
  10. การเรียกซ้ำลดขนาดของรหัสในขณะที่การวนซ้ำทำให้รหัสยาวขึ้น

สรุป:

ฟังก์ชั่นแบบเรียกซ้ำนั้นง่ายต่อการเขียน แต่มันทำงานได้ไม่ดีเมื่อเทียบกับการทำซ้ำในขณะที่การทำซ้ำนั้นยากที่จะเขียน

Top