编写一个C语言程序，要求实现带头结点的链表的以下功能： 链表初始化、按头插法链表A（用键盘依次输入链表A的元素值，以回车键结尾），按尾插法建立链表B，（用键盘依次输入链表B的元素值，以回车键结尾）、链表A的按值查找（在键盘上输入要查找链表A的值）、链表A的遍历、链表A的插入（提供机会在键盘上输入要插入的值和插入的位置）、链表A的删除（在键盘上输入要删除的值）、最后再把链表A和链表B进行合并，合并之后成链表C，要求链表C仍有序。（要求每一行程序都给出详尽的注释）

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

//定义链表结构体
typedef struct Node {
    int data;  //结点的数据
    struct Node* next;  //指向下一个结点的指针
} Node, *pNode;

//链表初始化函数：返回头结点指针
pNode initList() {
    pNode head = (pNode)malloc(sizeof(Node)); //分配头结点内存空间
    head->next = NULL;  //头结点的next指针初始化为NULL
    return head;  //返回头结点指针
}

//按头插法建立链表A
void createListA(pNode head) {
    int value;  //用于存储输入的值
    pNode p;  //定义新结点指针
    printf("请输入链表A的值（以-1结束）：");
    while (1) {
        scanf("%d", &value);  //输入结点的值
        if (value == -1) {  //当输入-1时结束输入
            break;
        }
        p = (pNode)malloc(sizeof(Node));  //分配新结点的内存空间
        p->data = value;  //将结点的值存储到新结点中
        p->next = head->next;  //将新结点的next指针指向头结点的下一个结点
        head->next = p;  //将头结点的next指针指向新结点，完成插入
    }
}

//按尾插法建立链表B
void createListB(pNode head) {
    int value;  //用于存储输入的值
    pNode p, tail;  //定义新结点指针和尾结点指针
    tail = head;  //初始化尾结点指针
    printf("请输入链表B的值（以-1结束）：");
    while (1) {
        scanf("%d", &value);  //输入结点的值
        if (value == -1) {  //当输入-1时结束输入
            break;
        }
        p = (pNode)malloc(sizeof(Node));  //分配新结点的内存空间
        p->data = value;  //将结点的值存储到新结点中
        tail->next = p;  //将尾结点的next指针指向新结点
        tail = p;  //更新尾结点指针，指向新的尾结点
    }
    tail->next = NULL;  //将尾结点的next指针指向NULL，表示链表结束
}

//链表A的按值查找函数：返回查找到的结点指针，未找到返回NULL
pNode findNode(pNode head, int value) {
    pNode p = head->next;  //定义结点指针，指向首结点
    while (p != NULL) {  //当链表没有结束时
        if (p->data == value) {  //当找到结点值等于目标值时
            return p;  //返回结点指针
        }
        p = p->next;  //指向下一个结点
    }
    return NULL;  //未找到，返回NULL
}

//链表A的遍历函数
void traverseList(pNode head) {
    pNode p = head->next;  //定义结点指针，指向首结点
    printf("链表A的值为：");
    while (p != NULL) {  //当链表没有结束时
        printf("%d ", p->data);  //输出结点的值
        p = p->next;  //指向下一个结点
    }
    printf("\n");
}

//链表A的插入函数：在第pos个位置插入值为value的结点
void insertNode(pNode head, int value, int pos) {
    int i = 0;  //计数器
    pNode p = head;  //定义结点指针，指向头结点
    while (p != NULL && i < pos - 1) {  //当链表没有结束且未找到插入位置时
        p = p->next;  //指向下一个结点
        i++;  //计数器加1
    }
    if (p == NULL || i > pos - 1) {  //当发现插入位置不合法时
        printf("插入位置不合法！\n");
        return;  //直接返回
    }
    pNode q = (pNode)malloc(sizeof(Node));  //分配新结点的内存空间
    q->data = value;  //将结点的值存储到新结点中
    q->next = p->next;  //将新结点的next指针指向p的下一个结点
    p->next = q;  //将p的next指针指向新结点，完成插入
}

//链表A的删除函数：删除第一个值为value的结点
void deleteNode(pNode head, int value) {
    pNode p = head;  //定义结点指针，指向头结点
    while (p->next != NULL && p->next->data != value) {  //当链表没有结束且未找到删除位置时
        p = p->next;  //指向下一个结点
    }
    if (p->next == NULL) {  //当未找到删除位置时
        printf("未找到要删除的结点！\n");
        return;  //直接返回
    }
    pNode q = p->next;  //定义临时指针，指向要删除的结点
    p->next = q->next;  //将p的next指针指向q的下一个结点，完成删除
    free(q);  //释放结点占用的内存空间
}

//链表合并函数：将链表B合并到链表A中，返回合并后的链表A的头结点指针
pNode mergeList(pNode headA, pNode headB) {
    pNode p = headA, q = headB, rear = headA;  //定义结点指针p和q，分别指向链表A和链表B的首结点，以及链表A的尾结点
    while (p->next != NULL && q->next != NULL) {  //当链表A和链表B都没有结束时
        if (p->next->data < q->next->data) {  //当链表A的值小于链表B的值时
            p = p->next;  //指向下一个结点，继续比较
        } else {  //否则
            rear->next = q->next;  //将链表B的首结点插入到链表A中
            q->next = q->next->next;  //将链表B的头结点移动到下一个结点
            rear->next->next = p->next;  //将链表B的首结点插入到链表A中
            rear = rear->next;  //更新链表A的尾结点
        }
    }
    if (q->next != NULL) {  //当链表B还有结点时
        rear->next = q->next;  //将链表B插入到链表A的末尾
    }
    free(headB);  //释放链表B的头结点占用的内存空间
    return headA;  //返回合并后的链表A的头结点指针
}

int main() {
    pNode headA, headB, headC;  //定义链表A、链表B、链表C的头结点指针
    int value, pos;  //用于存储输入的值和位置
    //初始化链表A、链表B、链表C的头结点
    headA = initList();
    headB = initList();
    headC = initList();
    //按头插法建立链表A
    createListA(headA);
    //按尾插法建立链表B
    createListB(headB);
    //链表A的按值查找
    printf("请输入要查找的值：");
    scanf("%d", &value);
    pNode node = findNode(headA, value);
    if (node != NULL) {
        printf("找到了！\n");
    } else {
        printf("未找到！\n");
    }
    //链表A的遍历
    traverseList(headA);
    //链表A的插入
    printf("请输入要插入的值和位置（用空格隔开）：");
    scanf("%d %d", &value, &pos);
    insertNode(headA, value, pos);
    traverseList(headA);
    //链表A的删除
    printf("请输入要删除的值：");
    scanf("%d", &value);
    deleteNode(headA, value);
    traverseList(headA);
    //链表合并
    headC->next = mergeList(headA, headB)->next;  //将头结点指向合并后的链表A的首结点
    printf("合并后的链表C的值为：");
    traverseList(headC);
    //释放链表C的内存空间
    pNode p = headC->next, q;
    while (p != NULL) {
        q = p;
        p = p->next;
        free(q);
    }
    free(headC);
    return 0;
}