（一）采用头插法创建单链表； （二）采用尾插法创建单链表； （三）单链表上插入结点算法； （四）在单链表中删除结点算法； （五）将单链表倒置（逆序存储）； （六）将两个有序单链表合并为一个有序单链表。用C语言

（一）采用头插法创建单链表
头插法创建单链表是指每次将新节点插入到链表的头部。以下是使用C语言实现的头插法创建单链表的示例代码：

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

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

// 创建新节点
Node* createNode(int data) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (!newNode) {
        printf("内存分配失败\n");
        exit(1);
    }
    newNode->data = data;
    newNode->next = NULL;
    return newNode;
}

// 头插法创建链表
Node* createListWithHeadInsertion() {
    Node* head = NULL; // 初始化头指针为空
    int data;
    while (scanf("%d", &data) && data != -1) { // 输入-1作为结束标志
        Node* newNode = createNode(data);
        newNode->next = head;
        head = newNode;
    }
    return head;
}

int main() {
    Node* list = createListWithHeadInsertion();
    // 打印链表
    Node* current = list;
    while (current != NULL) {
        printf("%d ", current->data);
        current = current->next;
    }
    // 释放链表内存
    current = list;
    while (current != NULL) {
        Node* temp = current;
        current = current->next;
        free(temp);
    }
    return 0;
}

（二）采用尾插法创建单链表
尾插法创建单链表是指每次将新节点插入到链表的尾部。以下是使用C语言实现的尾插法创建单链表的示例代码：

// 尾插法创建链表
Node* createListWithTailInsertion() {
    Node* head = NULL; // 初始化头指针为空
    Node* tail = NULL; // 尾指针用于记录链表的尾部
    int data;
    while (scanf("%d", &data) && data != -1) { // 输入-1作为结束标志
        Node* newNode = createNode(data);
        if (tail == NULL) {
            head = newNode;
        } else {
            tail->next = newNode;
        }
        tail = newNode;
    }
    return head;
}

（三）单链表上插入结点算法
在单链表中插入节点，需要修改插入位置前驱节点的next指针，使其指向新节点，并将新节点的next指针指向原节点。以下是使用C语言实现的单链表中插入节点的示例代码：

// 在链表中插入节点
void insertNode(Node** head, int data, int position) {
    Node* newNode = createNode(data);
    if (position == 0) { // 插入头部
        newNode->next = *head;
        *head = newNode;
    } else {
        Node* current = *head;
        for (int i = 0; current != NULL && i < position - 1; i++) {
            current = current->next;
        }
        if (current != NULL) {
            newNode->next = current->next;
            current->next = newNode;
        } else {
            printf("位置超出链表长度，无法插入\n");
            free(newNode);
        }
    }
}

（四）在单链表中删除结点算法
在单链表中删除节点，需要找到要删除节点的前驱节点，并修改其next指针指向要删除节点的后继节点。以下是使用C语言实现的单链表中删除节点的示例代码：

// 删除链表中的节点
void deleteNode(Node** head, int position) {
    if (*head == NULL) return;
    Node* temp = *head;
    if (position == 0) { // 删除头部
        *head = temp->next;
        free(temp);
    } else {
        Node* current = *head;
        for (int i = 0; current != NULL && i < position - 1; i++) {
            current = current->next;
        }
        if (current == NULL || current->next == NULL) {
            printf("位置超出链表长度，无法删除\n");
        } else {
            Node* next = current->next->next;
            free(current->next);
            current->next = next;
        }
    }
}

（五）将单链表倒置（逆序存储）
要将单链表倒置，可以遍历链表，逐个改变节点的指向。以下是使用C语言实现的单链表倒置的示例代码：

// 倒置链表
Node* reverseList(Node* head) {
    Node* prev = NULL;
    Node* current = head;
    Node* next = NULL;
    while (current != NULL) {
        next = current->next;
        current->next = prev;
        prev = current;
        current = next;
    }
    head = prev;
    return head;
}

（六）将两个有序单链表合并为一个有序单链表
合并两个有序单链表需要比较两个链表的头节点，将较小的节点接到新的链表上，并移动相应的指针。以下是使用C语言实现合并两个有序单链表的示例代码：

// 合并两个有序链表
Node* mergeTwoLists(Node* l1, Node* l2) {
    Node dummy;
    Node* tail = &dummy;
    dummy.next = NULL;
    while (l1 && l2) {
        if (l1->data < l2->data) {
            tail->next = l1;
            l1 = l1->next;
        } else {
            tail->next = l2;
            l2 = l2->next;
        }
        tail = tail->next;
    }
    tail->next = l1 ? l1 : l2;
    return dummy.next;
}