C语言在单链表中删除指定元素

C语言可以通过遍历单链表，找到需要删除的节点，然后将其前驱节点的指针指向其后继节点，再释放需要删除的节点的内存空间，即可完成删除操作。具体实现可以参考以下代码：

void deleteNode(Node* head, int val) {
    Node* cur = head;
    Node* pre = NULL;
    while (cur != NULL) {
        if (cur->val == val) {
            if (pre == NULL) {
                head = cur->next;
            } else {
                pre->next = cur->next;
            }
            free(cur);
            return;
        }
        pre = cur;
        cur = cur->next;
    }
}

其中，Node为单链表节点的结构体，val为节点的值，head为单链表的头节点指针。

相关问题

c语言在单链表指定位置删除元素

在C语言中，单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。要在单链表的指定位置删除元素，可以按照以下步骤进行：

1. **定义链表节点结构**：首先定义一个链表节点的结构体，包含数据和指向下一个节点的指针。

2. **创建链表**：编写函数来创建链表，插入节点等操作。

3. **删除指定位置的节点**：编写函数来删除指定位置的节点。

下面是一个示例代码，展示了如何在单链表中删除指定位置的元素：

#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));
    if (!newNode) {
        printf("Memory allocation error\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 在链表末尾插入节点
void append(struct Node** headRef, int data) {
    struct Node* newNode = createNode(data);
    if (*headRef == NULL) {
        *headRef = newNode;
        return;
    }
    struct Node* temp = *headRef;
    while (temp->next != NULL)
        temp = temp->next;
    temp->next = newNode;
}

// 删除指定位置的节点
void deleteNode(struct Node** headRef, int position) {
    if (*headRef == NULL)
        return;

    struct Node* temp = *headRef;

    // 如果头节点需要被删除
    if (position == 0) {
        *headRef = temp->next;
        free(temp);
        return;
    }

    // 找到要删除节点的前一个节点
    for (int i = 0; temp != NULL && i < position - 1; i++)
        temp = temp->next;

    // 如果位置超出范围
    if (temp == NULL || temp->next == NULL) {
        printf("Position out of range\n");
        return;
    }

    // 节点将被删除
    struct Node* next = temp->next->next;

    free(temp->next);

    temp->next = next;
}

// 打印链表
void printList(struct Node* head) {
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

// 主函数
int main() {
    struct Node* head = NULL;

    // 创建链表 1->2->3->4->5
    for (int i = 1; i <= 5; i++)
        append(&head, i);

    printf("Original list: \n");
    printList(head);

    // 删除位置2的节点
    deleteNode(&head, 2);

    printf("\nList after deleting node at position 2: \n");
    printList(head);

    return 0;
}

在这个示例中，我们首先定义了一个链表节点结构 `Node`，然后编写了 `createNode` 函数来创建新节点，`append` 函数来在链表末尾插入节点，`deleteNode` 函数来删除指定位置的节点，最后是 `printList` 函数来打印链表。

在 `main` 函数中，我们创建了一个链表并插入了5个节点，然后删除了位置2的节点并打印了结果。

用结构体和指针实现单链表的应用，具体包含：建立单链表、在单链表中查找指定元素、在单链表中插入指定元素、删除单链表某个元素。用C语言实现

好的，下面是单链表结构体和相关操作函数的实现：

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

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

// 建立单链表
Node* createList() {
    Node *head, *p, *q;
    int n, num;
    head = (Node*)malloc(sizeof(Node));
    head->next = NULL;
    q = head;
    printf("请输入链表的长度：");
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        printf("请输入第 %d 个元素：", i+1);
        scanf("%d", &num);
        p = (Node*)malloc(sizeof(Node));
        p->data = num;
        p->next = NULL;
        q->next = p;
        q = p;
    }
    return head;
}

// 查找指定元素
Node* search(Node* head, int x) {
    Node* p = head->next;
    while (p != NULL && p->data != x) {
        p = p->next;
    }
    return p;
}

// 在指定位置插入元素
void insert(Node* head, int pos, int x) {
    Node* p = head;
    for (int i = 0; i < pos-1; i++) {
        if (p->next == NULL) {
            printf("插入位置不合法！\n");
            return;
        }
        p = p->next;
    }
    Node* q = (Node*)malloc(sizeof(Node));
    q->data = x;
    q->next = p->next;
    p->next = q;
    printf("插入成功！\n");
}

// 删除指定元素
void del(Node* head, int x) {
    Node* p = head;
    while (p->next != NULL && p->next->data != x) {
        p = p->next;
    }
    if (p->next == NULL) {
        printf("要删除的元素不存在！\n");
        return;
    }
    Node* q = p->next;
    p->next = q->next;
    free(q);
    printf("删除成功！\n");
}

// 输出单链表
void printList(Node* head) {
    Node* p = head->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");
}

int main() {
    Node* head = createList();
    printf("链表中的元素为：");
    printList(head);
    int x;
    printf("请输入要查找的元素：");
    scanf("%d", &x);
    Node* p = search(head, x);
    if (p == NULL) {
        printf("要查找的元素不存在！\n");
    } else {
        printf("要查找的元素在链表中的位置为：%p\n", p);
    }
    int pos, num;
    printf("请输入要插入的位置和元素值：");
    scanf("%d %d", &pos, &num);
    insert(head, pos, num);
    printf("插入后的链表为：");
    printList(head);
    printf("请输入要删除的元素：");
    scanf("%d", &x);
    del(head, x);
    printf("删除后的链表为：");
    printList(head);
    return 0;
}