การเรียกซ้ำหรือในขณะที่ลูป

ฉันกำลังอ่านเกี่ยวกับการสัมภาษณ์การพัฒนาโดยเฉพาะเกี่ยวกับคำถามทางเทคนิคและการทดสอบที่ถามในการสัมภาษณ์และฉันได้พบคำพูดของประเภท "ไม่กี่ครั้ง" ตกลงคุณแก้ปัญหาด้วยการวนขณะนี้คุณสามารถทำกับ การเรียกซ้ำ "หรือ" ทุกคนสามารถแก้ปัญหานี้ด้วย 100 บรรทัดในขณะที่วนซ้ำ แต่พวกเขาสามารถทำได้ในฟังก์ชั่นวนซ้ำ 5 บรรทัดหรือไม่? " เป็นต้น

คำถามของฉันคือการเรียกซ้ำโดยทั่วไปดีกว่าถ้า / ในขณะ / สำหรับการสร้างหรือไม่

ฉันคิดเสมอว่าการเรียกซ้ำไม่ควรเลือกเพราะมัน จำกัด หน่วยความจำสแต็คที่เล็กกว่าฮีปมากการทำฟังก์ชั่น / เมธอดเป็นจำนวนมากนั้นไม่ดีเท่าที่ควร แต่ฉันอาจ จะผิด...

การเรียกซ้ำนั้นไม่ได้ดีกว่าหรือแย่กว่าการวนซ้ำมาก - แต่ละคนมีข้อดีและข้อเสียและผู้ใช้ก็ต้องพึ่งพาภาษาการเขียนโปรแกรม

ในทางเทคนิคแล้ววนซ้ำเหมาะกับระบบคอมพิวเตอร์ทั่วไปที่ดีกว่าในระดับฮาร์ดแวร์: ที่ระดับรหัสเครื่องการวนรอบเป็นเพียงการทดสอบและการกระโดดแบบมีเงื่อนไขในขณะที่การเรียกซ้ำ (นำไปใช้อย่างไร้เดียงสา) เกี่ยวข้องกับการผลักเฟรม จากสแต็ก OTOH หลายกรณีของการเรียกซ้ำ (โดยเฉพาะอย่างยิ่งผู้ที่มีความหมายเทียบเท่ากับลูปซ้ำ) สามารถเขียนได้เพื่อให้สามารถหลีกเลี่ยงการวางซ้อน / ป๊อปอัพได้ สิ่งนี้เป็นไปได้เมื่อการเรียกฟังก์ชันแบบเรียกซ้ำเป็นสิ่งสุดท้ายที่เกิดขึ้นในร่างกายของฟังก์ชั่นก่อนกลับมาและเป็นที่รู้จักกันโดยทั่วไปว่าเป็นการเพิ่มประสิทธิภาพการโทรหาง (หรือการเพิ่มประสิทธิภาพการเรียกซ้ำแบบหาง ) ฟังก์ชั่นการเรียกซ้ำแบบเรียกซ้ำที่ได้รับการออกแบบมาอย่างเหมาะสมนั้นส่วนใหญ่เทียบเท่ากับลูปวนซ้ำที่ระดับรหัสเครื่อง

สิ่งที่ต้องพิจารณาอีกประการคือลูปแบบวนซ้ำจำเป็นต้องมีการอัปเดตสถานะที่เป็นอันตรายซึ่งทำให้พวกมันขัดกับความหมายของภาษาที่บริสุทธิ์ (ไม่มีผลข้างเคียง) นี่คือเหตุผลที่ภาษาบริสุทธิ์อย่าง Haskell ไม่มีโครงสร้างวนซ้ำและภาษาโปรแกรมการทำงานอื่น ๆ อีกมากมายขาดทั้งภาษาอย่างสมบูรณ์หรือหลีกเลี่ยงพวกมันให้มากที่สุด

เหตุผลที่คำถามเหล่านี้ปรากฏในการสัมภาษณ์มากเป็นเพราะเพื่อตอบคำถามคุณต้องมีความเข้าใจอย่างถ่องแท้เกี่ยวกับแนวคิดการเขียนโปรแกรมที่สำคัญหลายอย่าง - ตัวแปรการเรียกใช้ฟังก์ชันขอบเขตและการวนซ้ำและการวนซ้ำ - และคุณมี เพื่อนำความยืดหยุ่นทางจิตมาไว้ในตารางที่ช่วยให้คุณเข้าถึงปัญหาจากมุมที่แตกต่างกันสองมุมและย้ายไปมาระหว่างการแสดงที่แตกต่างกันของแนวคิดเดียวกัน

ประสบการณ์และการวิจัยชี้ให้เห็นว่ามีเส้นแบ่งระหว่างคนที่มีความสามารถในการเข้าใจตัวแปรพอยน์เตอร์และการเรียกซ้ำและผู้ที่ไม่เข้าใจ เกือบทุกอย่างอื่นในการเขียนโปรแกรมรวมถึงเฟรมเวิร์ก API ภาษาการเขียนโปรแกรมและกรณีขอบของพวกเขาสามารถได้รับผ่านการศึกษาและประสบการณ์ แต่ถ้าคุณไม่สามารถพัฒนาสัญชาตญาณสำหรับแนวคิดหลักสามข้อนี้คุณก็ไม่เหมาะที่จะเป็นโปรแกรมเมอร์ การแปลลูปวนซ้ำแบบง่าย ๆ เป็นเวอร์ชันแบบเรียกซ้ำเป็นวิธีที่เร็วที่สุดในการกรองผู้ที่ไม่ใช่โปรแกรมเมอร์ - แม้ว่าโปรแกรมเมอร์ที่ไม่มีประสบการณ์จะสามารถทำได้ภายใน 15 นาทีและเป็นปัญหาทางภาษาดังนั้นผู้สมัครสามารถเลือกได้ ภาษาที่พวกเขาเลือกแทนที่จะสะดุดกับความงี่เง่า

หากคุณได้รับคำถามเช่นนี้ในการสัมภาษณ์นั่นเป็นสัญญาณที่ดีนั่นหมายถึงนายจ้างที่คาดหวังกำลังมองหาผู้ที่สามารถตั้งโปรแกรมไม่ใช่ผู้ที่จำคู่มือการเขียนโปรแกรมของเครื่องมือ

มันขึ้นอยู่กับ.

• ปัญหาบางอย่างคล้อยตามแนวทางแก้ไขซ้ำเช่นquicksort
• บางภาษาไม่รองรับการเรียกซ้ำเช่นFORTRAN ในช่วงต้น
• บางภาษาถือว่าการเรียกซ้ำเป็นวิธีหลักในการวนลูปเช่นHaskell

นอกจากนี้ยังเป็นที่น่าสังเกตว่าการรองรับการเรียกซ้ำแบบหางทำให้การวนซ้ำแบบซ้ำและการวนซ้ำแบบวนซ้ำนั้นเทียบเท่ากันนั่นคือการเรียกซ้ำไม่จำเป็นต้องเสียสแต็กเสมอไป

นอกจากนี้ขั้นตอนวิธี recursive จะสามารถนำมาใช้ซ้ำโดยใช้สแต็คอย่างชัดเจน

ในที่สุดฉันจะทราบว่าโซลูชันห้าบรรทัดน่าจะดีกว่า 100 บรรทัดเสมอ (สมมติว่าเทียบเท่ากันจริง ๆ )

ไม่มีการตกลงกันในระดับสากลเกี่ยวกับคำจำกัดความของ "ดีกว่า" เมื่อพูดถึงการเขียนโปรแกรม แต่ฉันจะพูดถึง "ง่ายต่อการดูแล / อ่าน"

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

ดังนั้นจากพลังงานที่มีความหมายต่ำถึงพลังงานที่มีความหมายสูงการวนลูปจะสร้างสแต็กแบบนี้:

• ฟังก์ชั่นเรียกซ้ำที่ใช้ข้อมูลที่ไม่เปลี่ยนรูปแบบ
• ฟังก์ชั่นวนซ้ำที่ใช้ข้อมูลที่ไม่เปลี่ยนรูปแบบ
• ในขณะที่ลูปที่ใช้ข้อมูลที่ไม่แน่นอน
• ฟังก์ชันเรียกซ้ำแบบหางที่ใช้ข้อมูลที่ไม่แน่นอน
• ฟังก์ชั่นวนซ้ำที่ใช้ข้อมูลที่ไม่แน่นอน

เป็นการดีที่คุณจะต้องใช้โครงสร้างที่แสดงออกน้อยที่สุดที่คุณสามารถทำได้ แน่นอนว่าหากภาษาของคุณไม่รองรับการปรับให้เหมาะสมแบบหางเรียกนั่นอาจส่งผลต่อการเลือกวนลูปของคุณ

การเรียกซ้ำบ่อยครั้งก็ชัดเจนน้อยกว่า ชัดเจนน้อยกว่าการบำรุงรักษายาก

หากคุณเขียนfor(i=0;i<ITER_LIMIT;i++){somefunction(i);}ในโฟลว์หลักคุณทำให้ชัดเจนว่าคุณกำลังเขียนลูป ถ้าคุณเขียนsomefunction(ITER_LIMIT);คุณไม่ได้ทำให้ชัดเจนว่าจะเกิดอะไรขึ้น การดูเนื้อหาเท่านั้น: การsomefunction(int x)โทรนั้นsomefunction(x-1)จะบอกคุณว่าในความเป็นจริงเป็นการวนซ้ำโดยใช้การวนซ้ำ นอกจากนี้คุณไม่สามารถวางเงื่อนไขการหลบหนีได้อย่างง่ายดายด้วยbreak;การทำซ้ำครึ่งทางคุณต้องเพิ่มเงื่อนไขที่จะผ่านไปตลอดทางหรือไม่ก็ยกเว้น (และข้อยกเว้นเพิ่มความซับซ้อนอีกครั้ง ... )

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

แน่นอนถ้ามันช่วยให้คุณประหยัด 98 บรรทัดนั่นเป็นเรื่องที่แตกต่างอย่างสิ้นเชิง

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

โดยพื้นฐานแล้วหากsomefunction(x-1)ต้องถูกเรียกจากภายในตัวเองมากกว่าหนึ่งครั้งต่อระดับให้ลืมการทำซ้ำ

... การเขียนฟังก์ชั่นซ้ำ ๆ สำหรับงานที่ทำได้ดีที่สุดโดยการเรียกซ้ำเป็นไปได้ แต่ไม่น่าพอใจ เมื่อใดก็ตามที่คุณต้องการใช้สิ่งที่คุณต้องชอบint stack<int>ฉันทำแบบฝึกหัดมากกว่าครั้งเดียวเพื่อการใช้งานจริง ฉันสามารถรับรองคุณได้เมื่อคุณเผชิญกับงานดังกล่าวคุณจะไม่มีข้อสงสัยเหมือนอย่างที่คุณแสดงออกมา

ตามปกตินี่เป็นคำตอบที่ไม่สามารถทำได้โดยทั่วไปเพราะมีปัจจัยเพิ่มเติมซึ่งในทางปฏิบัตินั้นไม่เท่ากันอย่างกว้างขวางระหว่างกรณีและไม่เท่ากันในกรณีการใช้งาน นี่คือแรงกดดันบางอย่าง

• รหัสสั้น ๆ ที่สง่างามนั้นโดยทั่วไปจะเหนือกว่ารหัสที่ยาวและซับซ้อน
• อย่างไรก็ตามจุดสุดท้ายนั้นค่อนข้างใช้งานไม่ได้หากฐานนักพัฒนาของคุณไม่คุ้นเคยกับการเรียกซ้ำและไม่เต็มใจ / ไม่สามารถเรียนรู้ได้ มันอาจกลายเป็นลบเล็กน้อยแทนที่จะเป็นบวก
• การเรียกซ้ำอาจไม่ดีสำหรับประสิทธิภาพหากคุณต้องการการโทรที่ซ้อนกันอย่างลึกซึ้งในทางปฏิบัติและคุณไม่สามารถใช้การเรียกซ้ำแบบหาง (หรือสภาพแวดล้อมของคุณไม่สามารถปรับการเรียกซ้ำแบบหางได้)
• การเรียกซ้ำเป็นสิ่งที่ไม่ดีในหลายกรณีหากคุณไม่สามารถแคชผลลัพธ์ระหว่างกลางได้อย่างเหมาะสม ยกตัวอย่างเช่นตัวอย่างทั่วไปของการใช้ recursion ต้นไม้ในการคำนวณตัวเลข Fibonacci ดำเนินการอย่างน่ากลัวไม่ดีถ้าคุณไม่แคช ถ้าคุณทำแคชมันง่ายรวดเร็วหรูหราและยอดเยี่ยมโดยสิ้นเชิง
• การเรียกซ้ำไม่สามารถใช้ได้กับบางกรณีเช่นเดียวกับการทำซ้ำในผู้อื่นและจำเป็นอย่างยิ่งสำหรับผู้อื่น การดิ้นรนผ่านกฎเกณฑ์ทางธุรกิจที่ยาวเหยียดมักไม่ได้รับการช่วยเหลือจากการสอบถามซ้ำทั้งหมด การวนซ้ำผ่านสตรีมข้อมูลสามารถทำได้อย่างมีประโยชน์ด้วยการเรียกซ้ำ การวนซ้ำข้ามโครงสร้างข้อมูลแบบไดนามิกหลายมิติ (เช่น mazes, ต้นไม้วัตถุ ... ) เป็นไปไม่ได้โดยไม่ต้องเรียกซ้ำ, ชัดเจนหรือโดยปริยาย ทราบว่าในกรณีเหล่านี้เรียกซ้ำอย่างชัดเจนเป็นมากดีกว่านัย - ไม่มีอะไรที่เป็นความเจ็บปวดมากขึ้นกว่าการอ่านรหัสที่ใครสักคนที่ดำเนินการเฉพาะกิจของตัวเองที่ไม่สมบูรณ์กองรถภายในภาษาเพียงเพื่อหลีกเลี่ยงความน่ากลัว R-คำ

การเรียกซ้ำเป็นเรื่องเกี่ยวกับการโทรซ้ำเพื่อใช้งานซ้ำการวนซ้ำเป็นการกระโดดซ้ำเพื่อวางในหน่วยความจำ

ควรพูดถึงเกี่ยวกับสแต็คโอเวอร์โฟลว์ - http://en.wikipedia.org/wiki/Stack_overflow

มันขึ้นอยู่กับความสะดวกหรือข้อกำหนด:

หากคุณใช้ภาษาโปรแกรมPythonจะรองรับการเรียกซ้ำ แต่โดยค่าเริ่มต้นจะมีข้อ จำกัด สำหรับความลึกของการเรียกซ้ำ (1,000) หากเกินขีด จำกัด เราจะได้รับข้อผิดพลาดหรือข้อยกเว้น ขีด จำกัด นั้นสามารถเปลี่ยนแปลงได้ แต่ถ้าเราทำเช่นนั้นเราอาจประสบกับสถานการณ์ที่ผิดปกติในภาษา

ในเวลานี้ (จำนวนการโทรมากกว่าความลึกการเรียกซ้ำ) เราต้องชอบการสร้างแบบวนซ้ำ ฉันหมายความว่าถ้าขนาดสแต็กไม่เพียงพอเราต้องชอบโครงสร้างลูป

ใช้รูปแบบการออกแบบกลยุทธ์

• การเรียกซ้ำนั้นสะอาด
• การวนซ้ำนั้นมีประสิทธิภาพ

ขึ้นอยู่กับโหลดของคุณ (และ / หรือเงื่อนไขอื่น ๆ ) ให้เลือก