คำถามติดแท็ก recursion

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

15 .net  exceptions  recursion  stackoverflow 

ด้วยฟังก์ชั่นซ้ำสองโดยพลการหนึ่งจะคำนวณเวลาการทำงานของมันได้อย่างไร ตัวอย่าง (ใน pseudocode): int a(int x){ if (x < = 0) return 1010; else return b(x-1) + a(x-1); } int b(int y){ if (y <= -5) return -2; else return b(a(y-1)); } หรือบางสิ่งบางอย่างตามเส้นเหล่านั้น วิธีการใดที่สามารถหรือควรใช้เพื่อกำหนดสิ่งนี้

15 recursion  big-o  runtime 

ทุกครั้งที่มีการอภิปรายเกี่ยวกับภาษาการเขียนโปรแกรมใหม่ที่กำหนดเป้าหมาย JVM ย่อมมีคนพูดถึงสิ่งต่าง ๆ เช่น: "JVM ไม่รองรับการปรับให้เหมาะสมแบบหางเรียกดังนั้นฉันทำนายสแต็กการระเบิดจำนวนมาก" ชุดรูปแบบนั้นมีการเปลี่ยนแปลงหลายพันรายการ ตอนนี้ฉันรู้ว่าบางภาษาเช่น Clojure มีโครงสร้างการเกิดขึ้นเป็นพิเศษที่คุณสามารถใช้ สิ่งที่ฉันไม่เข้าใจคือ: การขาดการเพิ่มประสิทธิภาพการโทรหางมีความร้ายแรงเพียงใด? ฉันควรกังวลเกี่ยวกับเรื่องนี้เมื่อใด แหล่งที่มาหลักของความสับสนอาจมาจากความจริงที่ว่า Java เป็นหนึ่งในภาษาที่ประสบความสำเร็จมากที่สุดและภาษา JVM บางส่วนดูเหมือนจะทำได้ค่อนข้างดี วิธีการที่เป็นไปได้ถ้าขาดการ TCO เป็นจริงของใด ๆกังวล?

14 recursion  stack  stackoverflow  tail-call 

ฉันเพิ่งสงสัยในใจ รูทีนย่อยต่อไปนี้ (เพื่อค้นหาองค์ประกอบในรายการ) มีคำสั่ง return ที่ท้าย: list *search_list(list *l, item_type x) { if (l == NULL) return(NULL); if (l->item == x) return(l); else return( search_list(l->next, x) ); } ฉันไม่สามารถรับความสำคัญของคำสั่ง return ในตอนท้าย (เช่น return search_list (l-> next, x)) มันจะมีประโยชน์จริง ๆ ถ้าใครสามารถอธิบายแนวคิดนี้โดยใช้โมเดลสแต็ก

14 functions  recursion 

ตามที่เป็นอยู่ในปัจจุบันคำถามนี้ไม่เหมาะสำหรับรูปแบบคำถาม & คำตอบของเรา เราคาดหวังคำตอบที่จะได้รับการสนับสนุนจากข้อเท็จจริงการอ้างอิงหรือความเชี่ยวชาญ แต่คำถามนี้มีแนวโน้มที่จะเรียกร้องให้มีการอภิปรายโต้แย้งโต้แย้งหรือการอภิปรายเพิ่มเติม หากคุณรู้สึกว่าคำถามนี้สามารถปรับปรุงและเปิดใหม่ได้โปรดไปที่ศูนย์ช่วยเหลือเพื่อขอคำแนะนำ ปิดให้บริการใน6 ปีที่ผ่านมา ฉันรู้ว่าการเรียกซ้ำคืออะไร (เมื่อ patten reoccurs อยู่ภายในตัวเองโดยทั่วไปแล้วฟังก์ชั่นที่เรียกตัวเองว่าเป็นหนึ่งในสายของมันหลังจากการแบ่งแบบมีเงื่อนไข ... ใช่ไหม?) และฉันสามารถเข้าใจฟังก์ชั่นแบบเรียกซ้ำได้ ปัญหาของฉันคือเมื่อฉันเห็นตัวอย่างใหม่ฉันมักสับสนอยู่เสมอ ถ้าฉันเห็นการวนซ้ำหรือการแมปการซิปการทำรังการเรียก polymorphic และอื่น ๆ ฉันรู้ว่าจะเกิดอะไรขึ้นโดยดูที่มัน เมื่อฉันเห็นรหัสซ้ำกระบวนการคิดของฉันมักจะเป็น 'wtf นี่คืออะไร' ตามด้วย 'oh it recursive' ตามด้วย 'ฉันเดาว่ามันต้องใช้งานถ้าพวกเขาบอกว่าทำ' คุณมีเคล็ดลับ / แผน / ทรัพยากรเพื่อสร้างทักษะในด้านนี้หรือไม่? การเรียกซ้ำเป็นแนวคิดแปลก ๆ ดังนั้นฉันจึงคิดวิธีจัดการกับมันอาจจะแปลกและไม่เท่าเทียมกันเท่ากัน

13 learning  functional-programming  lisp  haskell  recursion 

(หมายเหตุฉันใส่คำถามที่นี่เพราะมันเกี่ยวกับกลไกเชิงแนวคิดของมันไม่ใช่ปัญหาการเข้ารหัส) ผมทำงานในโปรแกรมขนาดเล็กที่ใช้ลำดับของตัวเลข fibonacci ใน equasion ของมัน แต่ผมสังเกตเห็นว่าถ้าผมได้มากกว่าจำนวนหนึ่งมันก็เจ็บปวดช้า googling รอบ bit ฉัน stumbled เมื่อเทคนิคใน Haskell ที่รู้จักกันเป็นMemoization, พวกเขาแสดงรหัสทำงานเช่นนี้: -- Traditional implementation of fibonacci, hangs after about 30 slow_fib :: Int -> Integer slow_fib 0 = 0 slow_fib 1 = 1 slow_fib n = slow_fib (n-2) + slow_fib (n-1) -- Memorized variant is …

12 haskell  recursion 

ฉันกำลังศึกษาเกี่ยวกับฟังก์ชั่นวนซ้ำและเห็นได้ชัดว่าพวกมันเป็นฟังก์ชันที่เรียกตัวเองและไม่ใช้การวนซ้ำ / วนซ้ำ อย่างไรก็ตามในขณะที่ท่องเว็บเพื่อดูตัวอย่าง (ปัญหา 8-queens-recursive) ฉันพบฟังก์ชันนี้: private boolean placeQueen(int rows, int queens, int n) { boolean result = false; if (row < n) { while ((queens[row] < n - 1) && !result) { queens[row]++; if (verify(row,queens,n)) { ok = placeQueen(row + 1,queens,n); } } if (!result) { queens[row] = …

12 java  recursion 

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

12 c++  recursion 

การเรียกซ้ำ - ตามที่เราทุกคนรู้ - เป็นหนึ่งในปัญหาเหล่านั้น - ที่ห่อหัวของคุณไปรอบ ๆ รู้สึกเหมือนได้รับ "เหตุการณ์สำคัญ" ในการเดินทางการเขียนโปรแกรมของคุณ แต่เมื่อพูดถึงการใช้งานจริงในปัญหาในโลกแห่งความจริง - การรู้กลไกของการเรียกซ้ำไม่เพียงพอ - เราต้องเข้าใจธรรมชาติของปัญหาที่การเรียกซ้ำเป็นวิธีที่เหมาะสมที่สุด ดังนั้นคำถามของฉันคือสิ่งนี้ ... อะไรคือ "รูปแบบปัญหา" ที่เรียกร้องให้แก้ปัญหาการเรียกซ้ำ เรียกใช้ซ้ำในรูปแบบของกลยุทธ์ "แบ่ง & พิชิต" หรือรูปแบบของ "การใช้รหัสซ้ำ" - หรือเป็นรูปแบบการออกแบบในสิทธิ์ของตนเอง คุณช่วยยกตัวอย่างปัญหาโลกแห่งความจริงให้เราทราบได้เมื่อการเรียกซ้ำเป็นวิธีแก้ปัญหาทันที - อัปเดต - คำตอบมากมายอ้างถึง "ปัญหาที่แท้จริง" ในฐานะการสำรวจต้นไม้, แฟคทอเรียล ฯลฯ ฉันต้องการ "ปัญหาที่แท้จริง" - ให้ฉันยกตัวอย่างให้คุณ ... เรามีข้อความขนาดใหญ่ (ข้อความประมาณ 30 MB เป็นรายการที่เชื่อมโยงstructs) และเราจำเป็นต้องสร้างดัชนีสำหรับการค้นหาข้อความแบบเต็ม เราต้องการเก็บดัชนีทั้งหมดในหน่วยความจำและจัดทำดัชนีข้อความใหม่ทุกๆ …

11 recursion 

ฉันดูที่http://programming.lispdream.com/blog/2011/06/recursion-vs-iteration/และฉันเห็นว่าการใช้งานแบบเรียกซ้ำและทำซ้ำของฟังก์ชันแฟคทอเรียลซ้ำแล้วซ้ำอีกจะใช้เวลานานกว่า รับ n = 1,000 ฉันไม่สามารถหาสาเหตุ (เขาไม่ได้อธิบาย แต่บอกว่ามันเป็นแบบฝึกหัดสำหรับผู้อ่าน) ขออภัยสำหรับความแปลกใหม่ของฉันทั้งหมดนี้

11 algorithms  lisp  recursion 

บางครั้งในการสัมภาษณ์ฉันอาจใช้การสอบถามซ้ำเพื่อแก้ปัญหา (เช่นการเพิ่ม1จำนวนเต็มความแม่นยำที่ไม่มีที่สิ้นสุด) หรือเมื่อปัญหานำเสนอตัวเองที่เหมาะสมในการใช้การสอบถามซ้ำ บางครั้งอาจเป็นเพราะการใช้การเรียกซ้ำหลายครั้งเพื่อแก้ปัญหาดังนั้นโดยไม่ต้องคิดมากการเรียกซ้ำจะใช้เพื่อแก้ปัญหา อย่างไรก็ตามสิ่งที่ต้องพิจารณาก่อนที่คุณจะสามารถตัดสินใจได้ว่าจะใช้การเรียกซ้ำเพื่อแก้ไขปัญหาได้อย่างไร ฉันมีความคิดบางอย่าง: หากเราใช้การเรียกซ้ำข้อมูลซึ่งลดลงครึ่งหนึ่งทุกครั้งดูเหมือนว่าไม่มีปัญหาในการเรียกซ้ำเนื่องจากข้อมูลทั้งหมดที่สามารถพอดีกับ RAM ขนาด 16GB หรือแม้กระทั่งฮาร์ดไดรฟ์ 8TB สามารถจัดการได้โดยการเรียกซ้ำเพียง 42 ระดับ (ดังนั้นจึงไม่มีการล้นสแต็ค (ฉันคิดว่าในสภาพแวดล้อมบางอย่างสแต็คอาจมีความลึก 4000 ระดับทางมากกว่า 42 แต่ในขณะเดียวกันก็ขึ้นอยู่กับว่าคุณมีตัวแปรเฉพาะที่คุณมีเท่าไรในแต่ละสแตกการโทร หากมีตัวแปรโลคัลจำนวนมากและเป็นขนาดหน่วยความจำไม่ใช่ระดับซึ่งกำหนดสแต็กโอเวอร์โฟลว์)) หากคุณคำนวณหมายเลขฟีโบนักชีโดยใช้การเรียกซ้ำแบบบริสุทธิ์คุณต้องกังวลเกี่ยวกับความซับซ้อนของเวลาเว้นแต่ว่าคุณจะแคชผลลัพธ์ระดับกลาง และวิธีการเกี่ยวกับการเพิ่ม1จำนวนเต็มความแม่นยำอนันต์? บางทีมันอาจจะเป็นที่ถกเถียงกันเช่นคุณจะทำงานกับตัวเลขที่มีความยาว 3000 หลักหรือยาว 4000 หลักใหญ่จนสามารถทำให้เกิดการล้นสแต็กหรือไม่ ฉันไม่ได้คิด แต่บางทีคำตอบคือไม่เราไม่ควรใช้การเรียกซ้ำ แต่ใช้ลูปธรรมดาเพราะถ้าในบางแอปพลิเคชันจำนวนจริง ๆ ต้องยาว 4000 หลักเพื่อตรวจสอบบางอย่าง คุณสมบัติของตัวเลขเช่นว่าเป็นจำนวนเฉพาะหรือไม่ คำถามสุดท้ายคือสิ่งที่ต้องพิจารณาก่อนที่คุณจะตัดสินใจใช้การเรียกซ้ำเพื่อแก้ไขปัญหา

10 algorithms  recursion 

ฉันใช้อัลกอริทึมซึ่งค่อนข้างซับซ้อนในการคำนวณและต้องการพยายามทำให้แน่ใจว่าฉันไม่ได้ทำงานที่ไม่จำเป็น มีโครงตาข่ายลูกบาศก์ nxnxn เช่นถ้า n = 2 ประกอบด้วย (0,0,0), (0,1,0), (1,0,0), (1,1,0), (0, 1,1), (0,0,1), (1,0,1), (1,1,1) จากขัดแตะนี้ฉันจะสร้างจุด m ซ้ำซ้ำทุกอย่างเช่น: solve(set_of_points) { if set_of_points.size = m, finish do some useful computation here for each point in lattice not in set_of_points: solve(set_of_points + new_point); } ซึ่งสามารถเรียกได้ว่าเริ่มต้นด้วย set_of_point ที่ว่างเปล่า ลักษณะของปัญหาที่เกิดขึ้นเป็นเช่นนั้นฉันไม่จริงต้องทุกการเปลี่ยนแปลงของจุดเมตรเพียงแค่คนที่เป็นเอกลักษณ์ภายใต้ symmetries ธรรมชาติของลูกบาศก์ …

10 algorithms  recursion 

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

10 recursion  advantages