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

ลิงก์ลิสต์แบบทางเดียว

โหนดและพอยน์เตอร์

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

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

  1. ลิงก์ลิสต์แบบทางเดียว
  2. การแทรกและการลบ
  3. การท่องผ่านและการค้นหา
  4. ลิงก์ลิสต์แบบสองทาง
← กลับไปที่ C Academy