การเรียกซ้ำโดยไม่มีแฟกทอเรียหมายเลขฟีโบนักชี ฯลฯ

เกือบทุกบทความที่ฉันสามารถหาได้เกี่ยวกับการเรียกซ้ำรวมถึงตัวอย่างของตัวเลขหรือตัวเลขฟีโบนักชีซึ่ง ได้แก่ :

1. คณิตศาสตร์
2. ไร้ประโยชน์ในชีวิตจริง

มีตัวอย่างโค้ดที่ไม่ใช่คณิตศาสตร์ที่น่าสนใจสำหรับสอนการเรียกซ้ำหรือไม่

ฉันคิดว่าอัลกอริทึมการหารและพิชิต แต่พวกเขามักจะเกี่ยวข้องกับโครงสร้างข้อมูลที่ซับซ้อน

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

void GetAllFilePaths(Directory dir, List<string> paths)
{
    foreach(File file in dir.Files)
    {
        paths.Add(file.Path);
    }

    foreach(Directory subdir in dir.Directories)
    {
        GetAllFilePaths(subdir, paths)
    }
}

List<string> GetAllFilePaths(Directory dir)
{
    List<string> paths = new List<string>();
    GetAllFilePaths(dir, paths);
    return paths;
}

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

สิ่งที่ต้องคิดเกี่ยวกับ:

• ระบบไฟล์ - โดยทั่วไปเป็นต้นไม้ ภารกิจการเขียนโปรแกรมที่ดีคือการดึงภาพ. jpg ทั้งหมดภายใต้ไดเรกทอรีที่แน่นอนและไดเรกทอรีย่อยทั้งหมด
• บรรพบุรุษ - ได้รับต้นไม้ตระกูล, พบจำนวนรุ่นที่คุณต้องเดินขึ้นไปหาบรรพบุรุษร่วมกัน; หรือตรวจสอบว่าคนสองคนในต้นไม้เป็นของรุ่นเดียวกันหรือไม่ หรือตรวจสอบว่าคนสองคนในต้นไม้สามารถแต่งงานอย่างถูกกฎหมาย (ขึ้นอยู่กับเขตอำนาจศาล :)
• เอกสารที่มีลักษณะคล้าย HTML - แปลงระหว่างการนำเสนอแบบอนุกรม (ข้อความ) ของเอกสารและแผนผัง DOM ดำเนินการกับชุดย่อยของ DOM (อาจใช้ชุดย่อยของ xpath?); ...

สิ่งเหล่านี้เกี่ยวข้องกับสถานการณ์ในโลกแห่งความเป็นจริงและสามารถนำไปใช้ในการใช้งานที่มีความสำคัญในโลกแห่งความจริง

https://stackoverflow.com/questions/105838/real-world-examples-of-recursion

• การสร้างแบบจำลองการติดเชื้อติดต่อ
• การสร้างรูปทรงเรขาคณิต
• การจัดการไดเรกทอรี
• การเรียงลำดับ

https://stackoverflow.com/questions/2085834/how-did-you-practically-use-recursion

• raytracing
• หมากรุก
• การแยกวิเคราะห์ซอร์สโค้ด (ไวยากรณ์ภาษา)

https://stackoverflow.com/questions/4945128/what-is-a-good-example-of-recursion-other-than-generating-a-fibonacci-sequence

• ค้นหา BST
• หอคอยแห่งฮานอย
• ค้นหา palindrome

https://stackoverflow.com/questions/126756/examples-of-recursive-functions

• ให้เรื่องราวภาษาอังกฤษที่ดีที่แสดงให้เห็นถึงการเรียกซ้ำโดยนิทานก่อนนอน

นี่คือปัญหาที่เกิดขึ้นจริงในใจของฉัน:

• รวมการเรียงลำดับ
• ค้นหาแบบทวิภาค
• การแวะการแทรกและการลบบนต้นไม้ (ส่วนใหญ่ใช้กับแอปพลิเคชันฐานข้อมูล)
• เครื่องกำเนิดพีชคณิต
• Sudoku solver (พร้อมการย้อนรอย)
• ตรวจสอบการสะกด (อีกครั้งด้วยการย้อนรอย)
• การวิเคราะห์ไวยากรณ์ (.eg ซึ่งเป็นโปรแกรมที่แปลงคำนำหน้าเป็นสัญลักษณ์ของ postfix)

QuickSort จะเป็นคนแรกที่ข้ามไปยังใจ การค้นหาแบบไบนารียังเป็นปัญหาซ้ำ นอกจากนั้นยังมีปัญหาทั้งชั้นเรียนที่การแก้ปัญหาแทบจะไม่มีค่าใช้จ่ายเมื่อคุณเริ่มทำงานกับการเรียกซ้ำ

เรียงลำดับกำหนดซ้ำใน Python

def sort( a ):
    if len(a) == 1: return a
    part1= sort( a[:len(a)//2] )
    part2= sort( a[len(a)//2:] )
    return merge( part1, part2 )

ผสานกำหนดซ้ำแล้วซ้ำอีก

def merge( a, b ):
    if len(b) == 0: return a
    if len(a) == 0: return b
    if a[0] < b[0]:
        return [ a[0] ] + merge(a[1:], b)
    else:
        return [ b[0] ] + merge(a, b[1:]) 

การค้นหาเชิงเส้นกำหนดซ้ำ

def find( element, sequence ):
    if len(sequence) == 0: return False
    if element == sequence[0]: return True
    return find( element, sequence[1:] )

การค้นหาแบบไบนารี่กำหนดแบบวนซ้ำ

def binsearch( element, sequence ):
    if len(sequence) == 0: return False
    mid = len(sequence)//2
    if element < mid: 
        return binsearch( element, sequence[:mid] )
    else:
        return binsearch( element, sequence[mid:] )

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

ตัวอย่างบางส่วนที่ไม่เกี่ยวข้องกับคณิตศาสตร์เพื่อสอนการเรียกซ้ำ (อย่างน้อยปัญหาเหล่านั้นที่ฉันจำได้จากปีที่เรียนมหาวิทยาลัย):

• หอคอยแห่งฮานอย
• แปดราชินี

นี่คือตัวอย่างของการใช้ Backtracking เพื่อแก้ไขปัญหา

ปัญหาอื่น ๆ คือคลาสสิกของโดเมนปัญญาประดิษฐ์: การใช้การค้นหาความลึกครั้งแรก, การค้นหาเส้นทาง, การวางแผน

ปัญหาทั้งหมดเหล่านั้นเกี่ยวข้องกับโครงสร้างข้อมูล "ที่ซับซ้อน" บางชนิด แต่ถ้าคุณไม่ต้องการสอนด้วยคณิตศาสตร์ (ตัวเลข) ตัวเลือกของคุณอาจมี จำกัด Yoy อาจต้องการเริ่มสอนด้วยโครงสร้างข้อมูลพื้นฐานเช่นรายการที่เชื่อมโยง ตัวอย่างเช่นการแทนตัวเลขธรรมชาติโดยใช้ List:

0 = รายการว่าง 1 = รายการที่มีหนึ่งโหนด 2 = รายการที่มี 2 โหนด ...

จากนั้นกำหนดผลรวมของตัวเลขสองตัวในแง่ของโครงสร้างข้อมูลเช่นนี้: ว่างเปล่า + N = N โหนด (X) + N = โหนด (X + N)

หอคอยแห่งฮานอยเป็นหอคอยที่ดีในการช่วยให้เรียนรู้การเรียกซ้ำ

มีวิธีแก้ไขปัญหามากมายบนเว็บในหลายภาษา

เครื่องตรวจจับ Palindrome:

เริ่มต้นด้วยสตริง: "ABCDEEDCBA" หากตัวอักษรเริ่มต้นและตัวลงท้ายมีค่าเท่ากันจากนั้นให้ย่อและตรวจสอบ "BCDEEDCB" ฯลฯ

อัลกอริทึมการค้นหาแบบไบนารีดูเหมือนสิ่งที่คุณต้องการ

ในภาษาโปรแกรมการทำงานเมื่อไม่มีฟังก์ชั่นการสั่งซื้อที่สูงกว่าการเรียกซ้ำถูกใช้แทนลูปที่จำเป็นเพื่อหลีกเลี่ยงสถานะที่ไม่แน่นอน

F # เป็นภาษาที่ใช้งานไม่ได้ซึ่งอนุญาตให้ทั้งสองสไตล์ดังนั้นฉันจะเปรียบเทียบทั้งสองที่นี่ ผลรวมต่อไปนี้เป็นตัวเลขทั้งหมดในรายการ

วนซ้ำกับตัวแปรไม่แน่นอน

let xlist = [1;2;3;4;5;6;7;8;9;10]
let mutable sum = 0
for x in xlist do
    sum <- sum + x

วนซ้ำแบบไม่มีสถานะไม่แน่นอน

let xlist = [1;2;3;4;5;6;7;8;9;10]
let rec loop sum xlist = 
    match xlist with
    | [] -> sum
    | x::xlist -> loop (sum + x) xlist
let sum = loop 0 xlist

โปรดทราบว่าชนิดของการรวมตัวนี้จะถูกบันทึกในฟังก์ชั่นการสั่งซื้อที่สูงขึ้นList.foldและอาจจะเขียนเป็นList.fold (+) 0 xlistหรือแน่นอนมากยิ่งขึ้นเพียงกับฟังก์ชั่นอำนวยความสะดวกเป็นเพียงแค่List.sumList.sum xlist

ฉันใช้การเรียกซ้ำอย่างหนักในเกมที่เล่น AI การเขียนด้วย C ++ ฉันใช้ฟังก์ชั่นประมาณ 7 ชุดที่เรียกกันตามลำดับ (ด้วยฟังก์ชั่นแรกที่มีตัวเลือกในการข้ามสิ่งเหล่านี้ทั้งหมดและเรียกแทนฟังก์ชันเพิ่มเติมอีก 2 ฟังก์ชัน) ฟังก์ชั่นสุดท้ายในห่วงโซ่ทั้งสองเรียกว่าฟังก์ชั่นแรกอีกครั้งจนกว่าความลึกที่เหลือฉันต้องการค้นหาไปที่ 0 ซึ่งในกรณีนี้ฟังก์ชั่นสุดท้ายจะเรียกฟังก์ชั่นการประเมินผลของฉันและส่งกลับคะแนนของตำแหน่ง

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

คุณสามารถดูโครงร่างพื้นฐานของโปรแกรมประเภทนี้ได้ที่https://secure.wikimedia.org/wikipedia/en/wiki/Minimax#Pseudocode

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

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

    class BomPart
    {
        public string PartNumber { get; set; }
        public string Desription { get; set; }
        public int Quantity { get; set; }
        public bool Plastic { get; set; }
        public List<BomPart> Components = new List<BomPart>();
    }

และการโทรซ้ำตัวอย่าง ...

    static int ComponentCount(BomPart part)
    {
        int subCount = 0;
        foreach(BomPart p in part.Components)
            subCount += ComponentCount(p);
        return part.Quantity * Math.Max(1,subCount);

    }

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

ความสัมพันธ์ในครอบครัวเป็นตัวอย่างที่ดีเพราะทุกคนเข้าใจโดยสัญชาตญาณ:

ancestor(joe, me) = (joe == me) 
                    OR ancestor(joe, me.father) 
                    OR ancestor(joe, me.mother);

การทำงานภายในที่เรียกว่า recursion ค่อนข้างไร้ประโยชน์ แต่เป็นการเรียกซ้ำstrlen():

size_t strlen( const char* str )
{
    if( *str == 0 ) {
       return 0;
    }
    return 1 + strlen( str + 1 );
}

ไม่มีคณิตศาสตร์ - ฟังก์ชั่นที่ง่ายมาก แน่นอนว่าคุณไม่ได้ใช้มันซ้ำในชีวิตจริง แต่เป็นตัวอย่างที่ดีของการเรียกซ้ำ

ปัญหาการเรียกซ้ำในโลกแห่งความเป็นจริงอีกอย่างหนึ่งที่นักเรียนอาจเกี่ยวข้องคือการสร้างโปรแกรมรวบรวมข้อมูลเว็บของตนเองที่ดึงข้อมูลจากเว็บไซต์และติดตามลิงค์ทั้งหมดภายในเว็บไซต์นั้น (และลิงก์ทั้งหมดจากลิงก์เหล่านั้น ฯลฯ )

ฉันแก้ปัญหาด้วยรูปแบบอัศวิน (บนกระดานหมากรุก) โดยใช้โปรแกรมแบบเรียกซ้ำ คุณควรจะย้ายอัศวินไปรอบ ๆ เพื่อให้มันสัมผัสทุกตารางยกเว้นสี่เหลี่ยมที่ทำเครื่องหมายไม่กี่

คุณเพียงแค่:

mark your "Current" square
gather a list of free squares that are valid moves
are there no valid moves?
    are all squares marked?
        you win!
for each free square
    recurse!
clear the mark on your current square.
return.    

สถานการณ์ "คิดล่วงหน้า" หลายประเภทสามารถทำงานได้โดยการทดสอบความเป็นไปได้ในอนาคตในต้นไม้เช่นนี้