ฟังก์ชั่นวนซ้ำสามารถมีการวนซ้ำ / ลูปได้หรือไม่?

ฉันกำลังศึกษาเกี่ยวกับฟังก์ชั่นวนซ้ำและเห็นได้ชัดว่าพวกมันเป็นฟังก์ชันที่เรียกตัวเองและไม่ใช้การวนซ้ำ / วนซ้ำ

อย่างไรก็ตามในขณะที่ท่องเว็บเพื่อดูตัวอย่าง (ปัญหา 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] = -1;
        }
    }else{
        result = true;
    }
    return result;
}

มีการwhileวนซ้ำที่เกี่ยวข้อง

... ดังนั้นตอนนี้ฉันหลงทาง ฉันสามารถใช้ลูปได้หรือไม่?

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

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

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

โครงสร้างทั่วไปของฟังก์ชันแบบเรียกซ้ำเป็นดังนี้:

myRecursiveFunction(inputValue)
begin
   if evaluateBaseCaseCondition(inputValue)=true then
       return baseCaseValue;
   else
       /*
       Recursive processing
       */
       recursiveResult = myRecursiveFunction(nextRecursiveValue); //nextRecursiveValue could be as simple as inputValue-1
       return recursiveResult;
   end if
end

ข้อความที่ฉันทำเครื่องหมายว่า/*recursive processing*/อาจเป็นอะไรก็ได้ มันอาจmyRecursiveFunctionรวมถึงห่วงหากปัญหาถูกแก้ไขต้องใช้มันและยังอาจรวมถึงการโทรเรียกซ้ำไป

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

การเรียกซ้ำและการวนซ้ำเป็นเพียงสองวิธี / โครงสร้างเพื่อใช้การคำนวณแบบวนซ้ำ

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

หลายภาษาให้คุณใช้ทั้งสองกลไกและคุณสามารถเลือกภาษาที่เหมาะกับคุณมากยิ่งขึ้นและแม้แต่ผสมเข้าด้วยกันในรหัสของคุณ ในภาษาที่จำเป็นเช่น C, C ++, Java เป็นต้นโดยปกติแล้วคุณจะใช้ a whileหรือforloop เมื่อคุณไม่ต้องการ stack และคุณใช้การเรียกซ้ำเมื่อคุณต้องการ stack (โดยปริยายใช้ stack โดยใช้ run-time) Haskell (ภาษาที่ใช้งานได้) ไม่มีโครงสร้างการควบคุมการทำซ้ำดังนั้นคุณจึงสามารถใช้การเรียกซ้ำเพื่อดำเนินการซ้ำได้

ในตัวอย่างของคุณ (ดูความคิดเห็นของฉัน):

// queens should have type int [] , not int.
private boolean placeQueen(int row, int [] queens, int n)
{
    boolean result = false;
    if (row < n)
    {
        // Iterate with queens[row] = 1 to n - 1.
        // After each iteration, you either have a result
        // in queens, or you have to try the next column for
        // the current row: no intermediate result.
        while ((queens[row] < n - 1) && !result)
        {
            queens[row]++;
            if (verify(row,queens,n))
            {
                // I think you have 'result' here, not 'ok'.
                // This is another loop (iterate on row).
                // The loop is implemented as a recursive call
                // and the previous values of row are stored on
                // the stack so that we can resume with the previous
                // value if the current attempt finds no solution.
                result = placeQueen(row + 1,queens,n);
            }
        }
        if (!result) {
            queens[row] = -1;
        }
    }else{
        result = true;
    }
    return result;
}

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

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

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

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

วิธีการในคำถามของคุณซ้ำ

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