C Academy · บทเรียน

การเรียกซ้ำทำงานอย่างไร

กรณีฐานและสแตกการเรียก

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

การเรียกซ้ำคืออะไร

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

ในภาษา C ฟังก์ชันใด ๆ สามารถเรียกใช้ตัวเองได้ ตราบใดที่มีวิธีทำให้การเรียกหยุดลงได้ในที่สุด

กรณีฐาน

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

หากไม่มีกรณีฐาน ฟังก์ชันจะเรียกตัวเองไปเรื่อย ๆ จนโปรแกรมขัดข้อง

int countdown(int n) {
    if (n == 0) return 0; /* base case */
    return countdown(n - 1);
}

กรณีเรียกซ้ำ

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

อาร์กิวเมนต์นั้นต้องเคลื่อนเข้าใกล้กรณีฐาน มิฉะนั้นการเรียกซ้ำจะไม่สิ้นสุด

int sum_to(int n) {
    if (n == 0) return 0;       /* base case */
    return n + sum_to(n - 1);   /* recursive case */
}

โปรแกรมสมบูรณ์โปรแกรมแรก

มาลองเรียกใช้โปรแกรมสมบูรณ์ที่หาผลรวมของจำนวนตั้งแต่ 1 ถึง 5 โดยใช้การเรียกซ้ำ

ผลลัพธ์ควรเป็น 15

#include <stdio.h>

int sum_to(int n) {
    if (n == 0) return 0;
    return n + sum_to(n - 1);
}

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

ติดตามการเรียกใช้

การไล่ติดตามการเรียกซ้ำด้วยตนเองช่วยให้เข้าใจได้ง่ายขึ้น สำหรับ sum_to(3):

sum_to(3) = 3 + sum_to(2)
sum_to(2) = 2 + sum_to(1)
sum_to(1) = 1 + sum_to(0)
sum_to(0) = 0

จากนั้นการเรียกต่าง ๆ จะคืนค่ากลับขึ้นมา: 1 แล้ว 3 แล้ว 6

สแตกการเรียกใช้

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

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

การไล่ลงและการคลายกลับ

การเรียกซ้ำมีสองช่วง การไล่ลงคือช่วงที่การเรียกยังคงลงลึกเข้าใกล้กรณีฐาน

การคลายกลับคือช่วงที่กรณีฐานคืนค่า แล้วการเรียกแต่ละครั้งทำงานของตนให้เสร็จโดยใช้ค่าที่คืนกลับมา

#include <stdio.h>

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

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

ค่าที่คืนไหลกลับขึ้นมา

ค่าที่คืนโดยการเรียกที่อยู่ลึกลงไปจะถูกใช้โดยการเรียกที่เป็นผู้เรียก

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

int power(int base, int exp) {
    if (exp == 0) return 1;
    return base * power(base, exp - 1);
}

การพิมพ์ระหว่างการเรียกซ้ำ

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

#include <stdio.h>

void down(int n) {
    if (n == 0) return;
    printf("%d ", n);
    down(n - 1);
}

int main(void) {
    down(5);
    printf("\n");
    return 0;
}

พิมพ์ระหว่างทางขึ้น

ย้าย printf ไปไว้หลังการเรียกซ้ำ แล้วลำดับจะกลับด้าน การเรียกที่ลึกที่สุดจะพิมพ์ก่อน

วิธีนี้จะพิมพ์ 1 2 3 4 5 แทนที่จะเป็น 5 4 3 2 1

#include <stdio.h>

void up(int n) {
    if (n == 0) return;
    up(n - 1);
    printf("%d ", n);
}

int main(void) {
    up(5);
    printf("\n");
    return 0;
}

กฎสองข้อที่ควรจำ

ฟังก์ชันแบบเรียกซ้ำที่ถูกต้องต้องปฏิบัติตามกฎสองข้อ:

1. มีกรณีฐานอย่างน้อยหนึ่งกรณีที่คืนค่าโดยไม่เรียกซ้ำ
2. การเรียกซ้ำทุกครั้งทำให้อาร์กิวเมนต์เข้าใกล้กรณีฐานมากขึ้น

หากละเมิดกฎข้อใดข้อหนึ่ง โปรแกรมจะวนซ้ำไม่สิ้นสุด

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจพื้นฐานเกี่ยวกับการเรียกซ้ำของคุณ

สรุปทบทวน

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

การเรียกใช้แต่ละครั้งใช้เฟรมบนสแตก และผลลัพธ์จะไหลกลับขึ้นมาเมื่อการเรียกต่าง ๆ คลายกลับ

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

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

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

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

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

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

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

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

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

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

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

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

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