用c语言封装链表的动态创建，删除，修改的函数

可以回答这个问题。以下是用 C 语言封装链表的动态创建、删除和修改的函数：

1. 动态创建链表：

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

Node *createList() {
    Node *head = (Node *)malloc(sizeof(Node));
    head->next = NULL;
    return head;
}

2. 动态删除链表：

void deleteList(Node *head) {
    Node *p = head;
    while (p != NULL) {
        Node *temp = p;
        p = p->next;
        free(temp);
    }
}

3. 修改链表中某个节点的值：

void modifyNode(Node *head, int index, int value) {
    Node *p = head->next;
    int i = 0;
    while (p != NULL && i < index) {
        p = p->next;
        i++;
    }
    if (p != NULL) {
        p->data = value;
    }
}

以上是用 C 语言封装链表的动态创建、删除和修改的函数。

相关问题

c语言用类封装单向链表

C语言中没有类的概念，但可以使用结构体和函数指针来实现链表的封装，下面是一个简单的单向链表封装示例。

#include <stdio.h>
#include <stdlib.h>

typedef struct _node {
    int value;
    struct _node* next;
} ListNode;

typedef struct _linked_list {
    ListNode* head;
    int size;
    void (*insert)(struct _linked_list*, int);
    void (*remove)(struct _linked_list*, int);
    void (*print)(struct _linked_list*);
    void (*clear)(struct _linked_list*);
} LinkedList;

void insert(LinkedList* list, int value) {
    ListNode* node = (ListNode*)malloc(sizeof(ListNode));
    node->value = value;
    node->next = NULL;

    if (list->head == NULL) {
        list->head = node;
    } else {
        ListNode* cur = list->head;
        while (cur->next) {
            cur = cur->next;
        }
        cur->next = node;
    }

    list->size++;
}

void remove_node(LinkedList* list, int value) {
    ListNode* cur = list->head;
    ListNode* prev = NULL;

    while (cur) {
        if (cur->value == value) {
            if (prev == NULL) {
                list->head = cur->next;
            } else {
                prev->next = cur->next;
            }
            free(cur);
            list->size--;
            return;
        }
        prev = cur;
        cur = cur->next;
    }
}

void print(LinkedList* list) {
    ListNode* cur = list->head;

    while (cur) {
        printf("%d ", cur->value);
        cur = cur->next;
    }

    printf("\n");
}

void clear(LinkedList* list) {
    ListNode* cur = list->head;

    while (cur) {
        ListNode* next = cur->next;
        free(cur);
        cur = next;
    }

    list->head = NULL;
    list->size = 0;
}

LinkedList* new_linked_list() {
    LinkedList* list = (LinkedList*)malloc(sizeof(LinkedList));
    list->head = NULL;
    list->size = 0;
    list->insert = insert;
    list->remove = remove_node;
    list->print = print;
    list->clear = clear;

    return list;
}

int main() {
    LinkedList* list = new_linked_list();

    list->insert(list, 1);
    list->insert(list, 2);
    list->insert(list, 3);

    list->print(list);

    list->remove(list, 2);

    list->print(list);

    list->clear(list);
    free(list);

    return 0;
}

在这个示例中，我们首先定义了两个结构体：`ListNode`和`LinkedList`。`ListNode`表示链表节点，包含一个整数值和指向下一个节点的指针。`LinkedList`表示链表本身，包含指向头节点的指针和链表中节点的数量，以及链表操作的函数指针。

然后，我们定义了一些函数来操作链表。`insert`函数用于在链表末尾插入一个新节点，新节点的值为传入的参数。`remove_node`函数用于从链表中删除一个节点，值为传入的参数。`print`函数用于打印链表中所有节点的值。`clear`函数用于清空链表中的所有节点，释放内存。

在`new_linked_list`函数中，我们创建了一个新的`LinkedList`对象，并将链表操作的函数指针赋值给相应的成员变量。在`main`函数中，我们使用`new_linked_list`函数创建了一个新的链表对象，然后使用链表操作的函数指针来操作链表。

这个示例只是一个简单的单向链表封装，如果需要更复杂的功能，可以在`LinkedList`结构体中添加更多的成员变量和函数，并在函数中实现更多的链表操作。

c语言利用子函数保存链表文件

可以将保存链表到文件的操作封装成一个子函数，以便在程序中重复利用。下面是一个示例代码，演示如何利用子函数将链表保存到文件中：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct Node {
    int id;
    char name[20];
    struct Node* next;
} Node;

// 将链表保存到文件中
int saveListToFile(Node* head, const char* fileName) {
    // 打开文件
    FILE* fp;
    fp = fopen(fileName, "w");
    if (fp == NULL) {
        printf("文件打开失败！\n");
        return 0;
    }

    // 遍历链表，将每个节点的数据写入文件
    Node* p = head;
    while (p != NULL) {
        fprintf(fp, "%d %s\n", p->id, p->name);
        p = p->next;
    }

    // 关闭文件
    fclose(fp);

    return 1;
}

int main() {
    // 创建链表
    Node* head = NULL;
    Node* tail = NULL;
    for (int i = 1; i <= 5; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->id = i;
        sprintf(node->name, "name%d", i);
        node->next = NULL;
        if (head == NULL) {
            head = node;
        } else {
            tail->next = node;
        }
        tail = node;
    }

    // 保存链表到文件中
    int result = saveListToFile(head, "data.txt");
    if (result) {
        printf("链表保存成功！\n");
    } else {
        printf("链表保存失败！\n");
    }

    // 释放链表占用的内存
    Node* p = head;
    while (p != NULL) {
        Node* next = p->next;
        free(p);
        p = next;
    }

    return 0;
}

在上面的示例代码中，我们将保存链表到文件的操作封装成了一个名为saveListToFile的子函数。该函数接受两个参数，分别为链表头指针和文件名。在函数内部，我们使用fopen函数打开文件，然后遍历链表，将每个节点的数据输出到文件中。最后，我们使用fclose函数关闭文件，并返回1表示操作成功。在主函数中，我们先创建了一个包含5个节点的链表，然后调用saveListToFile函数将链表保存到名为"data.txt"的文件中。最后，我们释放链表所占用的内存。