0Pricing
C Academy · บทเรียน

การท่องต้นไม้

เรียงลำดับกลาง ก่อน และหลัง

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

การท่องต้นไม้คืออะไร

การท่องต้นไม้คือวิธีการเยี่ยมชมโหนดทุกโหนดในต้นไม้อย่างเป็นระบบ โดยเยี่ยมชมแต่ละโหนดเพียงครั้งเดียว

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

การท่องแบบเรียงลำดับ

การท่องแบบเรียงลำดับจะเยี่ยมชมต้นไม้ย่อยด้านซ้าย จากนั้นจึงเยี่ยมชมโหนด แล้วจึงเยี่ยมชมต้นไม้ย่อยด้านขวา

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

void in_order(Node *root) {
    if (root == NULL) return;
    in_order(root->left);
    printf("%d ", root->value);
    in_order(root->right);
}

การท่องแบบก่อน

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

วิธีนี้เหมาะสำหรับการคัดลอกต้นไม้หรือสร้างนิพจน์แบบนำหน้า เพราะรากจะถูกส่งออกมาก่อนโหนดลูก

void pre_order(Node *root) {
    if (root == NULL) return;
    printf("%d ", root->value);
    pre_order(root->left);
    pre_order(root->right);
}

การท่องแบบหลัง

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

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

void post_order(Node *root) {
    if (root == NULL) return;
    post_order(root->left);
    post_order(root->right);
    printf("%d ", root->value);
}

รูปแบบร่วม

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

มีเพียงตำแหน่งของขั้นตอนการเยี่ยมชมเท่านั้นที่เป็นตัวกำหนดชื่อลำดับ

/* visit position decides the order:
 * pre  : VISIT, left, right
 * in   : left, VISIT, right
 * post : left, right, VISIT
 */

การท่องแบบเรียงลำดับจะแสดงค่าที่เรียงแล้ว

โปรแกรมนี้สร้าง BST ขนาดเล็กและเรียกใช้การท่องแบบเรียงลำดับ เพื่อสาธิตคุณสมบัติที่ผลลัพธ์จะเรียงลำดับ

ค่าต่าง ๆ จะออกมาตั้งแต่น้อยที่สุดไปจนถึงมากที่สุด โดยไม่ขึ้นกับลำดับการแทรก

#include <stdio.h>
#include <stdlib.h>

typedef struct Node { int value; struct Node *left, *right; } Node;
Node *cn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
Node *insert(Node *r,int v){
    if(!r) return cn(v);
    if(v<r->value) r->left=insert(r->left,v);
    else if(v>r->value) r->right=insert(r->right,v);
    return r;
}
void in_order(Node *r){ if(!r) return; in_order(r->left); printf("%d ", r->value); in_order(r->right); }

int main(void){
    Node *root=NULL;
    int d[]={10,5,15,3,7,12};
    for(int i=0;i<6;i++) root=insert(root,d[i]);
    in_order(root);
    printf("\n");
    return 0;
}

เปรียบเทียบทั้งสามลำดับ

สำหรับต้นไม้ที่มีรากเป็น 10 ด้านซ้ายเป็น 5 และด้านขวาเป็น 15 ผลลัพธ์จะแตกต่างกันดังนี้

แบบก่อนให้ผลลัพธ์ 10 5 15 แบบเรียงลำดับให้ผลลัพธ์ 5 10 15 แบบหลังให้ผลลัพธ์ 5 15 10 ค่าของโหนดเหมือนกันทั้งหมด ต่างกันเพียงจังหวะการเยี่ยมชม

/*        10
 *       /  \
 *      5    15
 * pre : 10 5 15
 * in  : 5 10 15
 * post: 5 15 10
 */

การท่องตามระดับ

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

เราใส่รากลงในคิว จากนั้นนำโหนดออกจากคิวซ้ำ ๆ แสดงโหนดนั้น แล้วใส่โหนดลูกลงในคิว

void level_order(Node *root) {
    if (!root) return;
    Node *queue[100];
    int head = 0, tail = 0;
    queue[tail++] = root;
    while (head < tail) {
        Node *n = queue[head++];
        printf("%d ", n->value);
        if (n->left)  queue[tail++] = n->left;
        if (n->right) queue[tail++] = n->right;
    }
}

การท่องต้นไม้ขับเคลื่อนงานจริง

การท่องต้นไม้เป็นแม่แบบสำหรับการทำงานใด ๆ ที่ต้องเข้าถึงทุกโหนด ไม่ใช่แค่การแสดงผล

เพียงเปลี่ยนขั้นตอนการเยี่ยมชมเป็นการหาผลรวมของค่า การหาค่าสูงสุด หรือการคัดลอกโหนด โครงสร้างเดิมก็สามารถทำงานเหล่านั้นได้

int sum_tree(Node *root) {
    if (root == NULL) return 0;
    return root->value
         + sum_tree(root->left)
         + sum_tree(root->right);
}

ต้นทุนของการท่องต้นไม้

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

การเรียกซ้ำใช้พื้นที่สแตกเป็นสัดส่วนกับความสูงของต้นไม้ ซึ่งเท่ากับ log(n) เมื่อต้นไม้สมดุล และเท่ากับ n ในกรณีที่แย่ที่สุด

ทั้งสามแบบในคราวเดียว

โปรแกรมนี้แสดงผลแบบก่อน แบบเรียงลำดับ และแบบหลังสำหรับต้นไม้เดียวกัน เพื่อให้คุณเปรียบเทียบได้โดยตรง

สังเกตว่ามีเพียงตำแหน่งของการเรียกแสดงผลเท่านั้นที่เปลี่ยนลำดับผลลัพธ์

#include <stdio.h>
#include <stdlib.h>

typedef struct Node { int value; struct Node *left, *right; } Node;
Node *cn(int v){ Node *n=malloc(sizeof(Node)); n->value=v; n->left=n->right=NULL; return n; }
void pre(Node *r){ if(!r) return; printf("%d ", r->value); pre(r->left); pre(r->right); }
void ino(Node *r){ if(!r) return; ino(r->left); printf("%d ", r->value); ino(r->right); }
void post(Node *r){ if(!r) return; post(r->left); post(r->right); printf("%d ", r->value); }

int main(void){
    Node *root = cn(10);
    root->left = cn(5); root->right = cn(15);
    pre(root);  printf("\n");
    ino(root);  printf("\n");
    post(root); printf("\n");
    return 0;
}

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

เลือกลำดับการท่องให้เหมาะกับงาน

สรุปทบทวน

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

การท่องตามระดับเป็นการท่องแบบกว้างและใช้คิว ทั้งหมดจะเยี่ยมชมแต่ละโหนดหนึ่งครั้ง โดยใช้เวลา O(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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

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

  1. โหนดและโครงสร้างต้นไม้
  2. แทรกข้อมูลใน BST
  3. การท่องต้นไม้
  4. ค้นหาและคืนหน่วยความจำ
← กลับไปที่ C Academy