C Academy · บทเรียน

การเรียกซ้ำเทียบกับการวนซ้ำ

ควรเลือกใช้แต่ละแบบเมื่อใด

การเรียกซ้ำเทียบกับการวนซ้ำ เป็นบทเรียน C Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน

วิธีทำซ้ำสองแบบ

ปัญหาหลายอย่างแก้ได้ทั้งด้วยการเรียกซ้ำหรือการวนซ้ำ การวนซ้ำใช้ลูป ส่วนการเรียกซ้ำใช้การเรียกฟังก์ชัน

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

แฟกทอเรียลด้วยลูป

นี่คือแฟกทอเรียลที่เขียนแบบวนซ้ำด้วยลูป for ไม่มีการเรียกฟังก์ชันตัวเอง แต่ใช้ตัวแปรเดียวสะสมผลคูณ

#include <stdio.h>

long factorial(int n) {
    long result = 1;
    for (int i = 2; i <= n; i++)
        result *= i;
    return result;
}

int main(void) {
    printf("%ld\n", factorial(6));
    return 0;
}

แฟกทอเรียลด้วยการเรียกซ้ำ

แบบเรียกซ้ำนั้นสั้นกว่าและสะท้อนนิยามทางคณิตศาสตร์โดยตรง

ทั้งสองแบบพิมพ์ค่า 720 สำหรับ factorial(6) แต่ใช้กลไกแตกต่างกัน

long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

ความแตกต่างด้านหน่วยความจำ

โดยทั่วไปการวนซ้ำใช้หน่วยความจำปริมาณคงที่และน้อย โดยมีเพียงตัวแปรเฉพาะที่ไม่กี่ตัว

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

ความแตกต่างด้านความเร็ว

การเรียกซ้ำแต่ละครั้งมีต้นทุนเล็กน้อย ได้แก่ การเตรียมเฟรมและการคืนค่าจากเฟรมนั้น

สำหรับงานนับจำนวนอย่างง่าย ลูปมักเร็วกว่าเล็กน้อย เพราะไม่ต้องเสียต้นทุนจากการเรียกดังกล่าว

เมื่อการเรียกซ้ำได้เปรียบ

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

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

เมื่อการวนซ้ำได้เปรียบ

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

นอกจากนี้ยังหลีกเลี่ยงความเสี่ยงที่สแตกจะล้นเมื่อมีข้อมูลนำเข้าขนาดใหญ่

int sum_array(int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++)
        total += a[i];
    return total;
}

งานเดียวกัน สองรูปแบบ

การหาผลรวมตั้งแต่ 1 ถึง n ทำได้ทั้งสองแบบ ต่อไปนี้คือแบบวนซ้ำที่คืนคำตอบเดียวกับการเรียกซ้ำ

#include <stdio.h>

int sum_to(int n) {
    int total = 0;
    for (int i = 1; i <= n; i++)
        total += i;
    return total;
}

int main(void) {
    printf("%d\n", sum_to(100));
    return 0;
}

เปลี่ยนการเรียกซ้ำเป็นลูป

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

การเรียกซ้ำเชิงเส้นอย่างง่าย เช่น แฟกทอเรียลหรือผลรวม สามารถเปลี่ยนเป็นลูปธรรมดาที่มีตัวแปรสะสมได้

#include <stdio.h>

int main(void) {
    int n = 5, result = 1;
    while (n > 1) { result *= n; n--; }
    printf("%d\n", result);
    return 0;
}

หมายเหตุเกี่ยวกับการเรียกซ้ำแบบหาง

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

C ไม่ได้รับประกันว่าจะทำเช่นนี้ ดังนั้นอย่าพึ่งพาพฤติกรรมนี้เมื่อเรียกซ้ำในระดับลึก

int sum_tail(int n, int acc) {
    if (n == 0) return acc;
    return sum_tail(n - 1, acc + n);
}

การเลือกแนวทาง

ลองถามว่า ปัญหานี้มีลักษณะซ้อนกันหรือเป็นแบบแบ่งแยกแล้วพิชิตโดยธรรมชาติหรือไม่ หากใช่ การเรียกซ้ำก็เหมาะสม

ถ้าเป็นการทำซ้ำเชิงเส้นอย่างง่ายและอาจมีข้อมูลนำเข้าขนาดใหญ่มาก การวนซ้ำจะปลอดภัยกว่าและมักเร็วกว่า

ตรวจสอบอย่างรวดเร็ว

เปรียบเทียบแนวทางทั้งสองแบบ

สรุปทบทวน

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

คำถามที่พบบ่อย

บทเรียน “การเรียกซ้ำเทียบกับการวนซ้ำ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การเรียกซ้ำเทียบกับการวนซ้ำ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส C Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การเรียกซ้ำเทียบกับการวนซ้ำ”

ควรเลือกใช้แต่ละแบบเมื่อใด คุณปฏิบัติ C Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน C Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน C Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 3 จากทั้งหมด 4 บทเรียน

บทเรียน “การเรียกซ้ำเทียบกับการวนซ้ำ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน C Academy นี้ได้ไหม

ได้ บทเรียน C Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ C Academy