操作系统——使用C语言实现单链表的创建、插入、删除，要求代表最简

时间：2025-04-08 07:04:53

Q:单链表是一种常见的数据结构，用于存储一系列具有相同类型的数据。在 C 语言中，可以通过定义一个结构体来表示链表的节点，并通过指针来链接各个节点。

以下是最简单的单链表的定义：

struct Node {
    int data;
    struct Node *next;
};

其中，data 表示节点存储的数据，next 表示指向下一个节点的指针。

接下来，我们可以实现单链表的创建、插入和删除操作：

创建一个空链表：

struct Node *head = NULL;

在链表末尾插入一个节点：


struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
new_node->data = value;
new_node->next = NULL;

if (head == NULL) {
    head = new_node;
} else {
    struct Node *cur = head;
    while (cur->next != NULL) {
        cur = cur->next;
    }
    cur->next = new_node;
}

其中，value 表示要插入的节点的数据。

在链表中删除一个节点：

if (head == NULL) {
    return;
}

if (head->data == value) {
    struct Node *tmp = head;
    head = head->next;
    free(tmp);
} else {
    struct Node *cur = head;
    while (cur->next != NULL && cur->next->data != value) {
        cur = cur->next;
    }
    if (cur->next == NULL) {
        return;
    }
    struct Node *tmp = cur->next;
    cur->next = cur->next->next;
    free(tmp);
}

其中，value 表示要删除的节点的数据。

这些操作可以组合起来，实现更复杂的功能。例如，可以编写一个函数来打印链表的所有节点：

void print_list(struct Node *head) {
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
}

这是一个基本的单链表实现，但它并不是最优化的。在实际开发中，需要根据具体需求和数据规模选择最合适的数据结构和算法。

Q：在unbantu中，使用C语言实现单链表的创建、插入、删除，要求代码最简
以下是使用 C 语言实现单链表的最简代码：

#include <>
#include <>

struct Node {
    int data;
    struct Node *next;
};

// 创建一个空链表
struct Node *head = NULL;

// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;

    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}

// 在链表中删除一个节点
void delete_node(int value) {
    if (head == NULL) {
        return;
    }

    if (head->data == value) {
        struct Node *tmp = head;
        head = head->next;
        free(tmp);
    } else {
        struct Node *cur = head;
        while (cur->next != NULL && cur->next->data != value) {
            cur = cur->next;
        }
        if (cur->next == NULL) {
            return;
        }
        struct Node *tmp = cur->next;
        cur->next = cur->next->next;
        free(tmp);
    }
}

int main() {
    insert_node(1);
    insert_node(2);
    insert_node(3);
    delete_node(2);
    insert_node(4);

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

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作，以及打印链表中所有节点的功能。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除

以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码：


#include <>
#include <>

struct Node {
    int data;
    struct Node *next;
};

// 创建一个空链表
struct Node *head = NULL;

// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;

    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}

// 在链表中删除一个节点
void delete_node(struct Node **head_ref, int value) {
    struct Node *cur = *head_ref;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return;
    }

    if (prev == NULL) {
        *head_ref = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
}

int main() {
    insert_node(1);
    insert_node(2);
    insert_node(3);
    delete_node(&head, 2);
    insert_node(4);

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

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），以及打印链表中所有节点的功能。在删除节点时，需要使用指向指针的指针来传递头节点的地址，以便在删除节点时更新头节点。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入所的值后再链表末尾插入一个结点
以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，以及创建单链表后插入所有的值并在链表末尾插入一个节点的功能：


#include <>
#include <>
struct Node {
    int data;
    struct Node *next;
};
// 创建一个空链表
struct Node *head = NULL;
// 在链表末尾插入一个节点
void insert_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
}
// 在链表中删除一个节点
void delete_node(struct Node **head_ref, int value) {
    struct Node *cur = *head_ref;
    struct Node *prev = NULL;
    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }
    if (cur == NULL) {
        return;
    }
    if (prev == NULL) {
        *head_ref = cur->next;
    } else {
        prev->next = cur->next;
    }
    free(cur);
}
int main() {
    int values[] = {1, 2, 3};
    int n = sizeof(values) / sizeof(int);
    // 插入所有值
    for (int i = 0; i < n; i++) {
        insert_node(values[i]);
    }
    // 插入一个新的节点
    insert_node(4);
    // 删除一个节点
    delete_node(&head, 2);
    // 打印链表中所有节点的值
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");
    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），以及创建单链表后插入所有的值并在链表末尾插入一个节点的功能。在删除节点时，需要使用指向指针的指针来传递头节点的地址，以便在删除节点时更新头节点。代码相对简单，但仍保持了基本的可读性和可维护性。注意，在使用 malloc 分配内存时，需要对返回值进行检查以确保内存分配成功。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入节点和创建节点分开实现。
以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，分开实现节点创建和链表创建：


#include <>
#include <>

struct Node {
    int data;
    struct Node *next;
};

// 创建一个空链表
struct Node *create_list() {
    return NULL;
}

// 在链表末尾插入一个节点
struct Node *insert_node(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表中删除一个节点
struct Node *delete_node(struct Node *head, int value) {
    struct Node *cur = head;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return head;
    }

    if (prev == NULL) {
        head = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
    return head;
}

// 创建一个新节点
struct Node *create_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

int main() {
    // 创建一个空链表
    struct Node *head = create_list();

    // 创建所有的节点
    struct Node *node1 = create_node(1);
    struct Node *node2 = create_node(2);
    struct Node *node3 = create_node(3);
    struct Node *node4 = create_node(4);

    // 插入所有节点
    head = insert_node(head, node1);
    head = insert_node(head, node2);
    head = insert_node(head, node3);

    // 在链表末尾插入一个新节点
    head = insert_node(head, node4);

    // 删除一个节点
    head = delete_node(head, 2);

    // 打印链表中所有节点的值
    struct Node *cur = head;
    while (cur != NULL) {
        printf("%d ", cur->data);
        cur = cur->next;
    }
    printf("\n");

    return 0;
}

这段代码实现了单链表的创建、插入和删除操作（按指针删除），并将节点创建和链表创建分开实现。在创建和插入节点时，我们使用了不同的函数来分离不同的功能。这样可以让代码更加清晰和易于维护。在删除节点时，我们需要返回新的头节点，因此需要更新函数的返回值。代码的逻辑相对简单，但仍保持了基本的可读性和可维护性。

Q:在unbantu中，使用C语言实现单链表的创建、插入、删除三个代码，要求删除的时候按照指针删除，创建单链表后插入节点和创建节点分开实现，实现单独插入一个结点，单独删除一个节点，在头部添加一个结点，在头部删除一个结点，在尾部添加一个节点，在尾部删除一个节点。

以下是使用 C 语言实现单链表的创建、插入、删除（按指针删除）的代码，分开实现节点创建和链表创建，并实现了插入和删除不同位置节点的功能：

#include <>
#include <>

struct Node {
    int data;
    struct Node *next;
};

// 创建一个空链表
struct Node *create_list() {
    return NULL;
}

// 在链表末尾插入一个节点
struct Node *insert_node(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表中删除一个节点
struct Node *delete_node(struct Node *head, int value) {
    struct Node *cur = head;
    struct Node *prev = NULL;

    while (cur != NULL && cur->data != value) {
        prev = cur;
        cur = cur->next;
    }

    if (cur == NULL) {
        return head;
    }

    if (prev == NULL) {
        head = cur->next;
    } else {
        prev->next = cur->next;
    }

    free(cur);
    return head;
}

// 在链表头部插入一个节点
struct Node *insert_head(struct Node *head, struct Node *new_node) {
    new_node->next = head;
    head = new_node;
    return head;
}

// 在链表头部删除一个节点
struct Node *delete_head(struct Node *head) {
    if (head == NULL) {
        return head;
    }
    struct Node *cur = head;
    head = head->next;
    free(cur);
    return head;
}

// 在链表尾部插入一个节点
struct Node *insert_tail(struct Node *head, struct Node *new_node) {
    if (head == NULL) {
        head = new_node;
    } else {
        struct Node *cur = head;
        while (cur->next != NULL) {
            cur = cur->next;
        }
        cur->next = new_node;
    }
    return head;
}

// 在链表尾部删除一个节点
struct Node *delete_tail(struct Node *head) {
    if (head == NULL) {
        return head;
    }
    struct Node *cur = head;
    struct Node *prev = NULL;
    while (cur->next != NULL) {
        prev = cur;
        cur = cur->next;
    }
    if (prev == NULL) {
        head = NULL;
    } else {
        prev->next = NULL;
    }
    free(cur);
    return head;
}

// 创建一个新节点
struct Node *create_node(int value) {
    struct Node *new_node = (struct Node*) malloc(sizeof(struct Node));
    new_node->data = value;
    new_node->next = NULL;
    return new_node;
}

int main() {
    // 创建一个空链表
    struct Node *head = create_list();

    // 创建所有的节点
    struct Node *node1 = create_node(1);
    struct Node *node2 = create_node(2);
    struct Node *node3 = create_node(3);
    struct Node *node4 = create_node(4);

    // 插入所有节点
    head = insert_node(head, node1)
head = insert_node(head, node2);
head = insert_node(head, node3);
head = insert_node(head, node4);

// 在链表末尾插入一个节点
struct Node *new_node1 = create_node(5);
head = insert_tail(head, new_node1);

// 在链表中删除一个节点
head = delete_node(head, 3);

// 在链表头部插入一个节点
struct Node *new_node2 = create_node(0);
head = insert_head(head, new_node2);

// 在链表头部删除一个节点
head = delete_head(head);

// 在链表尾部插入一个节点
struct Node *new_node3 = create_node(6);
head = insert_tail(head, new_node3);

// 在链表尾部删除一个节点
head = delete_tail(head);

// 输出链表中所有节点的值
struct Node *cur = head;
while (cur != NULL) {
    printf("%d ", cur->data);
    cur = cur->next;
}
printf("\n");

// 释放所有节点
cur = head;
while (cur != NULL) {
    struct Node *temp = cur;
    cur = cur->next;
    free(temp);
}

return 0;
}

在这个实现中，我们使用 create_node 函数创建一个新节点。 insert_node 函数用于将新节点插入链表中。 delete_node 函数用于删除链表中的某个节点。 insert_head 和 delete_head 分别用于在链表头部插入和删除节点。 insert_tail 和 delete_tail 分别用于在链表尾部插入和删除节点。

在 main 函数中，我们首先创建一个空链表。然后创建所有的节点，并将它们插入链表中。接下来，我们在链表末尾插入一个节点，删除链表中的某个节点，插入一个节点到链表头部，删除链表头部的节点，插入一个节点到链表尾部，删除链表尾部的节点。最后，我们输出链表中所有节点的值，然后释放所有节点的内存。

相关文章