在C语言版的数据结构中删除单链表头结点的代码

在C语言中，删除单链表的头结点通常涉及到对指针的操作，因为头结点没有前驱节点，所以我们需要修改头结点的指向。以下是一个简单的示例：

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

// 定义链表节点结构体
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// 函数声明，用于删除头结点
Node* deleteHead(Node** head) {
    // 如果链表为空，直接返回NULL
    if (*head == NULL)
        return NULL;
    
    // 删除头结点，并更新头结点指针
    Node* temp = *head;
    *head = (*head)->next;

    // 释放原头结点的内存
    free(temp);

    return *head;
}

int main() {
    Node* head = malloc(sizeof(Node));  // 初始化一个空链表
    // ... 其他链表操作 ...

    // 删除头结点
    head = deleteHead(&head);
    // ... 继续处理链表 ...

    return 0;
}

相关问题

数据结构与算法 带表头结点的单链表

带表头结点的单链表是一种常见的链表实现方式，它在链表头部额外添加了一个特殊的结点作为表头，用于简化链表的操作。

表头结点的数据域可以为空，或者存储一些表示链表长度或其他信息的值。而表头结点的指针域则指向链表的第一个有效结点。

下面是一个示例代码来创建带表头结点的单链表：

#include <iostream>

struct ListNode {
    int val;
    ListNode* next;
    ListNode(int x) : val(x), next(nullptr) {}
};

class LinkedList {
public:
    LinkedList() {
        head = new ListNode(0);  // 创建表头结点，其值为0
    }

    void insert(int val) {
        ListNode* newNode = new ListNode(val);
        newNode->next = head->next;
        head->next = newNode;
    }

    void remove(int val) {
        ListNode* prev = head;
        ListNode* curr = head->next;
        while (curr) {
            if (curr->val == val) {
                prev->next = curr->next;
                delete curr;
                break;
            }
            prev = curr;
            curr = curr->next;
        }
    }

    void display() {
        ListNode* curr = head->next;
        while (curr) {
            std::cout << curr->val << " ";
            curr = curr->next;
        }
        std::cout << std::endl;
    }

private:
    ListNode* head;
};

使用示例：

int main() {
    LinkedList list;
    list.insert(3);
    list.insert(5);
    list.insert(2);
    list.insert(7);
    list.display();  // 输出: 7 2 5 3

    list.remove(5);
    list.display();  // 输出: 7 2 3

    return 0;
}

写一份C语言带表头结点单链表的归并排序函数代码

在C语言中，我们通常不会直接对单链表进行原地的归并排序（因为链表不是随机访问数据结构，不适合快速查找和交换元素），而是会先将其转换为数组或其他可排序的数据结构，然后再进行归并排序。但是，如果你只是想了解如何在内存中操作两个已排序的链表节点合并成一个有序链表，这里是一个示例，展示如何合并两个单链表的节点：

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

typedef struct ListNode {
    int val;
    struct ListNode *next;
} ListNode;

// 合并两个已排序链表
ListNode* mergeSortedLists(ListNode* l1, ListNode* l2) {
    ListNode dummy = {0, NULL}; // 创建虚拟头节点，方便后续处理
    ListNode* tail = &dummy;    // 当前尾指针

    while (l1 != NULL && l2 != NULL) {
        if (l1->val <= l2->val) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }

    // 如果其中一个链表还有剩余元素，则将剩余部分连接到结果链表末尾
    if (l1 != NULL) {
        tail->next = l1;
    } else {
        tail->next = l2;
    }

    return dummy.next; // 返回合并后的实际链表头节点
}

// 假设你已经有了两个已排序的链表节点作为输入
void printList(ListNode* head) {
    ListNode* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->val);
        curr = curr->next;
    }
    printf("\n");
}

// 示例用法
int main() {
    // 创建两个已排序的小链表
    ListNode* list1 = create_sorted_list({1, 3, 5});
    ListNode* list2 = create_sorted_list({2, 4, 6});

    ListNode* mergedList = mergeSortedLists(list1, list2);

    printList(mergedList);  // 输出：1 2 3 4 5 6

    free(list1);
    free(list2);
    free(mergedList);  // 别忘了释放内存

    return 0;
}

请注意，上述代码并没有真正实现归并排序，而是在内存中合并两个已经排序好的链表。如果要实现整个归并排序过程，你需要首先将链表转换为数组，然后递归地分割、排序和合并子数组，再将结果合并回链表。这将涉及到更复杂的逻辑和更多的代码。