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