用c语言写单链表的创建、插入、删除、查找、显示

### 回答1：
单链表是一种常用的数据结构，它由一个节点序列组成，每个节点包含两部分：数据域和指针域。数据域存储节点的数据，指针域指向下一个节点。

下面是用C语言实现单链表的创建、插入、删除、查找和显示的代码：

1. 创建单链表

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

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

struct node *create_list(int n) {
    int i;
    struct node *head, *p, *q;
    head = (struct node *)malloc(sizeof(struct node));
    head->next = NULL;
    q = head;
    for (i = 0; i < n; i++) {
        p = (struct node *)malloc(sizeof(struct node));
        printf("请输入第%d个节点的值: ", i+1);
        scanf("%d", &p->data);
        q->next = p;
        q = p;
    }
    q->next = NULL;
    return head;
}

2. 插入节点

struct node *insert_node(struct node *head, int pos, int data) {
    int i;
    struct node *p, *q;
    p = head;
    for (i = 0; i < pos-1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("插入位置无效.\n");
        return head;
    }
    q = (struct node *)malloc(sizeof(struct node));
    q->data = data;
    q->next = p->next;
    p->next = q;
    return head;
}

3. 删除节点

struct node *delete_node(struct node *head, int pos) {
    int i;
    struct node *p, *q;
    p = head;
    for (i = 0; i < pos-1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL || p->next == NULL) {
        printf("删除位置无效.\n");
        return head;
    }
    q = p->next;
    p->next = q->next;
    free(q);
    return head;
}

4. 查找节点

int search_node(struct node *head, int data) {
    int pos = 0;
    struct node *p = head->next;
    while (p != NULL) {
        pos++;
        if (p->data == data) {
            return pos;
        }
        p = p->next;
    }
    return -1;  // 没找到
}

5. 显示链表

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

完整代码如下：

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

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

struct node *create_list(int n) {
    int i;
    struct node *head, *p, *q;
    head = (struct node *)malloc(sizeof(struct node));
    head->next = NULL;
    q = head;
    for (i = 0; i < n; i++) {
        p = (struct node *)malloc(sizeof(struct node));
        printf("请输入第%d个节点的值: ", i+1);
        scanf("%d", &p->data);
        q->next = p;
        q = p;
    }
    q->next = NULL;
    return head;
}

struct node *insert_node(struct node *head, int pos, int data) {
    int i;
    struct node *p, *q;
    p = head;
    for (i = 0; i < pos-1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL) {
        printf("插入位置无效.\n");
        return head;
    }
    q = (struct node *)malloc(sizeof(struct node));
    q->data = data;
    q->next = p->next;
    p->next = q;
    return head;
}

struct node *delete_node(struct node *head, int pos) {
    int i;
    struct node *p, *q;
    p = head;
    for (i = 0; i < pos-1 && p != NULL; i++) {
        p = p->next;
    }
    if (p == NULL || p->next == NULL) {
        printf("删除位置无效.\n");
        return head;
    }
    q = p->next;
    p->next = q->next;
    free(q);
    return head;
}

int search_node(struct node *head, int data) {
    int pos = 0;
    struct node *p = head->next;
    while (p != NULL) {
        pos++;
        if (p->data == data) {
            return pos;
        }
        p = p->next;
    }
    return -1;  // 没找到
}

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

int main() {
    struct node *head, *p;
    int n, pos, data;
    int choice = 1;
    printf("请输入链表的长度: ");
    scanf("%d", &n);
    head = create_list(n);
    while (choice) {
        printf("请选择要执行的操作:\n");
        printf("1. 插入节点\n");
        printf("2. 删除节点\n");
        printf("3. 查找节点\n");
        printf("4. 显示链表\n");
        printf("0. 退出程序\n");
        scanf("%d", &choice);
        switch (choice) {
            case 1:
                printf("请输入要插入的位置和数据: ");
                scanf("%d %d", &pos, &data);
                head = insert_node(head, pos, data);
                break;
            case 2:
                printf("请输入要删除的位置: ");
                scanf("%d", &pos);
                head = delete_node(head, pos);
                break;
            case 3:
                printf("请输入要查找的数据: ");
                scanf("%d", &data);
                pos = search_node(head, data);
                if (pos != -1) {
                    printf("数据%d在链表中的位置是%d\n", data, pos);
                } else {
                    printf("数据%d不在链表中\n", data);
                }
                break;
            case 4:
                display_list(head);
                break;
            case 0:
                printf("程序已退出.\n");
                break;
            default:
                printf("无效的选择.\n");
                break;
        }
    }
    p = head;
    while (p != NULL) {
        head = p->next;
        free(p);
        p = head;
    }
    return 0;
}

### 回答2：
单链表是一种常见的数据结构，用于存储和操作一组数据。下面将用C语言实现单链表的创建、插入、删除、查找和显示。

创建单链表：
首先，定义一个结构体表示链表的节点，包含数据和指向下一个节点的指针。

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

然后，定义一个头节点作为链表的起始节点。

Node* head = NULL;

插入节点：
插入节点可以在链表的任意位置进行。以下是在链表的末尾插入节点的例子。

void insertNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = NULL;
    
    if (head == NULL) {
        head = newNode;
    } else {
        Node* current = head;
        while (current->next != NULL) {
            current = current->next;
        }
        current->next = newNode;
    }
}

删除节点：
删除节点可以根据节点的值或位置进行。以下是根据节点值删除节点的例子。

void deleteNode(int data) {
    if (head == NULL) {
        return;
    }
    
    Node* current = head;
    Node* prev = NULL;
    
    if (current->data == data) {
        head = current->next;
        free(current);
        return;
    }
    
    while (current != NULL && current->data != data) {
        prev = current;
        current = current->next;
    }
    
    if (current == NULL) {
        return;
    }
    
    prev->next = current->next;
    free(current);
}

查找节点：
查找节点可以通过节点的值或位置进行。以下是根据节点值查找节点的例子。

Node* findNode(int data) {
    Node* current = head;
    
    while (current != NULL && current->data != data) {
        current = current->next;
    }
    
    return current;
}

显示单链表：
显示单链表可以遍历链表中的节点，并将节点的值输出。以下是显示单链表的例子。

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

通过以上程序，我们可以实现单链表的创建、插入、删除、查找和显示。

### 回答3：
单链表是一种常见的数据结构，可以用来存储和操作一系列的元素。下面是使用C语言实现单链表的创建、插入、删除、查找和显示的代码：

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

// 定义链表节点的结构体
struct ListNode {
    int value;
    struct ListNode* next;
};

// 创建链表
struct ListNode* createList(int num) {
    struct ListNode* head = NULL;
    struct ListNode* tail = NULL;
    
    for (int i = 1; i <= num; i++) {
        struct ListNode* node = (struct ListNode*)malloc(sizeof(struct ListNode));
        node->value = i;
        node->next = NULL;
        
        if (head == NULL) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    
    return head;
}

// 在链表的指定位置插入节点
void insertNode(struct ListNode** head, int pos, int value) {
    struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
    newNode->value = value;
    newNode->next = NULL;
    
    if (pos <= 0) {
        newNode->next = *head;
        *head = newNode;
    } else {
        struct ListNode* curr = *head;
        int i = 1;
        
        while (curr != NULL && i < pos) {
            curr = curr->next;
            i++;
        }
        
        if (curr != NULL) {
            newNode->next = curr->next;
            curr->next = newNode;
        }
    }
}

// 删除链表中指定节点
void deleteNode(struct ListNode** head, int value) {
    struct ListNode* prev = NULL;
    struct ListNode* curr = *head;
    
    while (curr != NULL && curr->value != value) {
        prev = curr;
        curr = curr->next;
    }
    
    if (curr != NULL) {
        if (prev == NULL) {
            *head = curr->next;
        } else {
            prev->next = curr->next;
        }
        
        free(curr);
    }
}

// 查找链表中指定值的节点
struct ListNode* searchNode(struct ListNode* head, int value) {
    struct ListNode* curr = head;
    
    while (curr != NULL && curr->value != value) {
        curr = curr->next;
    }
    
    return curr;
}

// 显示链表中的所有节点值
void displayList(struct ListNode* head) {
    struct ListNode* curr = head;
    
    while (curr != NULL) {
        printf("%d ", curr->value);
        curr = curr->next;
    }
    
    printf("\n");
}

int main() {
    struct ListNode* head = createList(5);
    displayList(head);
    
    insertNode(&head, 0, 10);
    displayList(head);
    
    deleteNode(&head, 3);
    displayList(head);
    
    struct ListNode* node = searchNode(head, 4);
    if (node != NULL) {
        printf("找到了节点 %d\n", node->value);
    } else {
        printf("未找到节点\n");
    }
    
    return 0;
}

以上代码实现了单链表的创建、插入、删除、查找和显示功能。在`main`函数中，首先通过`createList`函数创建了一个包含5个节点的链表，并通过`displayList`函数将链表的节点值打印出来。

然后，使用`insertNode`函数在链表的指定位置（0 表示在头部插入）插入了一个值为10的节点，并再次使用`displayList`函数将链表的节点值打印出来。

接着，使用`deleteNode`函数删除了链表中值为3的节点，并再次使用`displayList`函数将链表的节点值打印出来。

最后，使用`searchNode`函数查找了链表中值为4的节点，并根据节点是否为空来判断是否找到了节点。