ลิงก์ลิสต์แบบทางเดียว
โหนดและพอยน์เตอร์
ลิงก์ลิสต์แบบทางเดียว เป็นบทเรียน C Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน C Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส C Academy มีบทเรียนทั้งหมด 4 บทเรียน
ลิงก์ลิสต์คืออะไร
ลิงก์ลิสต์คือสายโซ่ของสตรักต์ขนาดเล็กที่เรียกว่า โหนด แต่ละโหนดเก็บค่าและพอยน์เตอร์ไปยังโหนดถัดไป
ต่างจากอาร์เรย์ตรงที่สมาชิกไม่จำเป็นต้องอยู่ติดกันในหน่วยความจำ และลิสต์สามารถเพิ่มหรือลดขนาดได้ง่าย
#include <stdio.h>
struct Node {
int value;
struct Node *next;
};
int main(void) {
printf("A node holds a value and a next pointer\n");
return 0;
}การกำหนดโหนด
สตรักต์ของโหนดประกอบด้วยข้อมูลและ struct Node *next ซึ่งชี้ไปยังโหนดถัดไป
ชนิดของพอยน์เตอร์อ้างถึงสตรักต์เดียวกัน นี่คือวิธีที่ทำให้สายโซ่เชื่อมต่อกัน
#include <stdio.h>
struct Node {
int value;
struct Node *next;
};
int main(void) {
struct Node n;
n.value = 42;
n.next = NULL;
printf("value=%d, next is NULL: %d\n", n.value, n.next == NULL);
return 0;
}พอยน์เตอร์ส่วนหัว
ลิสต์จะระบุด้วยพอยน์เตอร์เพียงตัวเดียวที่ชี้ไปยังโหนดแรก ซึ่งเรียกว่า ส่วนหัว
ลิสต์ว่างคือกรณีที่ส่วนหัวมีค่าเป็น NULL
#include <stdio.h>
struct Node { int value; struct Node *next; };
int main(void) {
struct Node *head = NULL;
printf("List is empty: %d\n", head == NULL);
return 0;
}การจัดสรรโหนด
โดยปกติจะสร้างโหนดบนฮีปด้วย malloc เพื่อให้โหนดมีอายุอยู่นานกว่าฟังก์ชันที่สร้างโหนดนั้น
ตรวจสอบค่าที่คืนกลับมาเสมอ และอย่าลืมคืนหน่วยความจำของโหนดภายหลัง
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
int main(void) {
struct Node *n = malloc(sizeof(struct Node));
n->value = 7;
n->next = NULL;
printf("%d\n", n->value);
free(n);
return 0;
}ตัวดำเนินการลูกศร
เมื่อคุณมี พอยน์เตอร์ ไปยังสตรักต์ ให้ใช้ -> เพื่อเข้าถึงสมาชิก n->value มีความหมายเหมือนกับ (*n).value
คุณจะใช้ตัวดำเนินการลูกศรอยู่เสมอเมื่อทำงานกับลิงก์ลิสต์
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
int main(void) {
struct Node *n = malloc(sizeof(struct Node));
n->value = 99;
printf("%d\n", n->value);
free(n);
return 0;
}การเชื่อมโหนดสองโหนด
หากต้องการเชื่อมโหนด ให้กำหนด next ของโหนดแรกให้ชี้ไปยังโหนดที่สอง ส่วน next ของโหนดสุดท้ายจะคงเป็น NULL เพื่อระบุจุดสิ้นสุด
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
int main(void) {
struct Node *a = malloc(sizeof(struct Node));
struct Node *b = malloc(sizeof(struct Node));
a->value = 1; a->next = b;
b->value = 2; b->next = NULL;
printf("%d -> %d\n", a->value, a->next->value);
free(a); free(b);
return 0;
}ตัวช่วยสร้างโหนด
การจัดสรรหน่วยความจำซ้ำ ๆ เป็นงานที่ยุ่งยาก จึงควรห่อหุ้มไว้ในฟังก์ชันตัวช่วยที่จัดสรรหน่วยความจำ กำหนดค่าเริ่มต้น และคืนค่าโหนดใหม่
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
struct Node *make(int v) {
struct Node *n = malloc(sizeof(struct Node));
n->value = v;
n->next = NULL;
return n;
}
int main(void) {
struct Node *n = make(5);
printf("%d\n", n->value);
free(n);
return 0;
}การสร้างลิสต์ขนาดเล็ก
ใช้ฟังก์ชันตัวช่วยสร้างลิสต์สามโหนด 1 -> 2 -> 3 โดยเชื่อมพอยน์เตอร์ next เข้าด้วยกัน
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}
int main(void) {
struct Node *head = make(1);
head->next = make(2);
head->next->next = make(3);
printf("%d %d %d\n", head->value, head->next->value, head->next->next->value);
return 0;
}การพิมพ์ลิสต์
หากต้องการพิมพ์ค่าทุกค่า ให้เริ่มที่ส่วนหัวและตามพอยน์เตอร์ next ไปจนกว่าจะถึง NULL
รูปแบบการไล่ผ่านนี้เป็นพื้นฐานของการดำเนินการกับลิสต์แทบทั้งหมด
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}
int main(void) {
struct Node *head = make(1);
head->next = make(2);
for (struct Node *p = head; p; p = p->next)
printf("%d ", p->value);
printf("\n");
return 0;
}อาร์เรย์กับลิงก์ลิสต์
อาร์เรย์เข้าถึงข้อมูลด้วยดัชนีได้รวดเร็วแต่มีขนาดตายตัว ส่วนลิงก์ลิสต์แทรกและลบข้อมูลได้ง่ายกว่าแต่เข้าถึงช้ากว่า เพราะต้องไล่ผ่านไปจนถึงสมาชิกที่ต้องการ
เลือกใช้ตามประเภทการดำเนินการที่โปรแกรมของคุณใช้เป็นหลัก
#include <stdio.h>
int main(void) {
printf("Array: O(1) index, costly resize\n");
printf("List: O(n) index, cheap insert/delete\n");
return 0;
}การคืนหน่วยความจำของรายการทั้งหมด
ต้องคืนหน่วยความจำของโหนดทุกโหนดที่จัดสรรด้วย malloc เดินไปตามรายการ แต่ต้องบันทึกตัวชี้ไปยังโหนดถัดไป ก่อน คืนหน่วยความจำของแต่ละโหนด มิฉะนั้นจะสูญเสียส่วนที่เหลือของสายโซ่
#include <stdio.h>
#include <stdlib.h>
struct Node { int value; struct Node *next; };
struct Node *make(int v){struct Node*n=malloc(sizeof*n);n->value=v;n->next=NULL;return n;}
int main(void) {
struct Node *head = make(1);
head->next = make(2);
struct Node *p = head;
while (p) {
struct Node *nxt = p->next;
free(p);
p = nxt;
}
printf("freed all nodes\n");
return 0;
}ตรวจสอบความเข้าใจอย่างรวดเร็ว
ทดสอบความเข้าใจเกี่ยวกับโครงสร้างรายการเชื่อมโยง
สรุปทบทวน
คุณได้เรียนรู้พื้นฐานของรายการเชื่อมโยงแบบทางเดียวแล้ว:
- โหนดเก็บค่าและตัวชี้
nextส่วนหัวรายการชี้ไปยังโหนดแรก - จัดสรรโหนดด้วย
mallocและเข้าถึงสมาชิกด้วย-> nextของโหนดสุดท้ายคือNULLให้ท่องรายการโดยติดตามตัวชี้- ต้องคืนหน่วยความจำของทุกโหนดเสมอ โดยบันทึกค่า
nextก่อนคืนหน่วยความจำ
คำถามที่พบบ่อย
บทเรียน “ลิงก์ลิสต์แบบทางเดียว” ฟรีหรือไม่
ใช่ — ข้อความเต็มของ “ลิงก์ลิสต์แบบทางเดียว” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ 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 ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ
บทเรียนทั้งหมดในหลักสูตรนี้
- ลิงก์ลิสต์แบบทางเดียว
- การแทรกและการลบ
- การท่องผ่านและการค้นหา
- ลิงก์ลิสต์แบบสองทาง