c语言如何创造单链表

C语言如何创造单链表

在C语言中创造单链表的步骤包括：定义节点结构、创建新节点、插入节点、删除节点、遍历链表。其中，定义节点结构是最基础和关键的一步。

定义节点结构是创建单链表的第一步。单链表中的每个节点都需要包含两个部分：存储数据的部分和指向下一个节点的指针。通过定义一个包含这两部分的结构体，我们可以为单链表定义节点。在C语言中，这通常通过struct关键字来实现。

一、定义节点结构

在C语言中，定义一个节点结构通常使用结构体（struct）。结构体包含两个部分：一个是存储数据的部分，另一个是指向下一个节点的指针。以下是一个简单的节点结构定义：

struct Node {

    int data;              // 数据部分
    struct Node* next;     // 指向下一个节点的指针
};

这段代码定义了一个名为Node的结构体，每个节点包含一个整数数据和一个指向下一个节点的指针。

二、创建新节点

创建新节点是链表操作中最基本的操作之一。在C语言中，创建一个新节点通常使用malloc函数来动态分配内存。以下是一个创建新节点的示例函数：

struct Node* createNode(int data) {

    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

这段代码定义了一个函数createNode，它接受一个整数数据作为参数，并返回一个指向新创建节点的指针。malloc函数用于为新节点分配内存，并将数据存储在节点的data部分。

三、插入节点

插入节点是链表操作中最常见的操作之一。插入节点可以分为几种情况：在链表头部插入、在链表尾部插入以及在链表中间某个位置插入。以下是这几种插入操作的示例代码：

1. 在链表头部插入节点：

void insertAtHead(struct Node head, int data) {

    struct Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}

2. 在链表尾部插入节点：

void insertAtTail(struct Node head, int data) {

    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}

3. 在链表中间某个位置插入节点：

void insertAfter(struct Node* prevNode, int data) {

    if (prevNode == NULL) {
        printf("The given previous node cannot be NULL");
        return;
    }
    struct Node* newNode = createNode(data);
    newNode->next = prevNode->next;
    prevNode->next = newNode;
}

四、删除节点

删除节点是链表操作中另一个常见操作。删除节点也可以分为几种情况：删除头节点、删除尾节点以及删除链表中间某个节点。以下是这几种删除操作的示例代码：

1. 删除头节点：

void deleteHead(struct Node head) {

    if (*head == NULL) {
        return;
    }
    struct Node* temp = *head;
    *head = (*head)->next;
    free(temp);
}

2. 删除尾节点：

void deleteTail(struct Node head) {

    if (*head == NULL) {
        return;
    }
    if ((*head)->next == NULL) {
        free(*head);
        *head = NULL;
        return;
    }
    struct Node* temp = *head;
    while (temp->next->next != NULL) {
        temp = temp->next;
    }
    free(temp->next);
    temp->next = NULL;
}

3. 删除链表中间某个节点：

void deleteNode(struct Node head, int key) {

    struct Node* temp = *head;
    struct Node* prev = NULL;
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return;
    prev->next = temp->next;
    free(temp);
}

五、遍历链表

遍历链表是对链表进行操作的基本步骤之一。通过遍历链表，我们可以访问每个节点的数据。以下是一个遍历链表的示例函数：

void traverse(struct Node* head) {

    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULLn");
}

这个函数从头节点开始，遍历整个链表并打印每个节点的数据，直到到达链表末尾（NULL）。

六、综合实例

为了更好地理解以上操作，我们可以结合所有操作，创建一个综合实例。以下是一个完整的示例程序，包括创建链表、插入节点、删除节点和遍历链表：

#include <stdio.h>

#include <stdlib.h>
struct Node {
    int data;
    struct Node* next;
};
struct Node* createNode(int data) {
    struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}
void insertAtHead(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    newNode->next = *head;
    *head = newNode;
}
void insertAtTail(struct Node head, int data) {
    struct Node* newNode = createNode(data);
    if (*head == NULL) {
        *head = newNode;
        return;
    }
    struct Node* temp = *head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
}
void insertAfter(struct Node* prevNode, int data) {
    if (prevNode == NULL) {
        printf("The given previous node cannot be NULL");
        return;
    }
    struct Node* newNode = createNode(data);
    newNode->next = prevNode->next;
    prevNode->next = newNode;
}
void deleteHead(struct Node head) {
    if (*head == NULL) {
        return;
    }
    struct Node* temp = *head;
    *head = (*head)->next;
    free(temp);
}
void deleteTail(struct Node head) {
    if (*head == NULL) {
        return;
    }
    if ((*head)->next == NULL) {
        free(*head);
        *head = NULL;
        return;
    }
    struct Node* temp = *head;
    while (temp->next->next != NULL) {
        temp = temp->next;
    }
    free(temp->next);
    temp->next = NULL;
}
void deleteNode(struct Node head, int key) {
    struct Node* temp = *head;
    struct Node* prev = NULL;
    if (temp != NULL && temp->data == key) {
        *head = temp->next;
        free(temp);
        return;
    }
    while (temp != NULL && temp->data != key) {
        prev = temp;
        temp = temp->next;
    }
    if (temp == NULL) return;
    prev->next = temp->next;
    free(temp);
}
void traverse(struct Node* head) {
    struct Node* temp = head;
    while (temp != NULL) {
        printf("%d -> ", temp->data);
        temp = temp->next;
    }
    printf("NULLn");
}
int main() {
    struct Node* head = NULL;
    insertAtHead(&head, 1);
    insertAtHead(&head, 2);
    insertAtTail(&head, 3);
    insertAfter(head, 4);
    printf("Linked List: ");
    traverse(head);
    deleteHead(&head);
    printf("After deleting head: ");
    traverse(head);
    deleteTail(&head);
    printf("After deleting tail: ");
    traverse(head);
    deleteNode(&head, 4);
    printf("After deleting node with data 4: ");
    traverse(head);
    return 0;
}

这个示例程序展示了如何创建一个简单的单链表，并演示了插入、删除和遍历操作。通过理解和运行这个程序，你可以更好地掌握在C语言中操作单链表的基本方法和技巧。

相关问答FAQs：

1. 什么是单链表？
单链表是一种常用的数据结构，用于存储一系列具有相同类型的数据元素，每个元素都包含一个数据项和一个指向下一个元素的指针。

2. 如何创建一个空的单链表？
要创建一个空的单链表，你需要定义一个指向头节点的指针，并将其初始化为NULL。头节点是一个特殊的节点，它不包含数据，只用于标识链表的起始位置。

3. 如何向单链表中添加新的节点？
要向单链表中添加新的节点，你需要先创建一个新的节点，并将数据赋值给新节点的数据项。然后，将新节点的指针指向链表中的下一个节点，再将链表中上一个节点的指针指向新节点。这样就成功地将新节点添加到了单链表中。