（1）实现单链表的创建；（2）实现单链表的插入；（3）实现单链表的删除（4）实现单链表的查找；（5）实现单链表的显示；两个线性表合并算法的实现。已知顺序表LA和LB中的数据元素按值非递减有序排列，现要将LA和LB归并为一个新的顺序表LC，且LC中的数据元素仍按值非递减有序排序。例如：LA＝（3,5,8,11） LB＝（2,6,9,15,20）。

1. 实现单链表的创建：

单链表的创建可以通过定义一个结构体来实现，结构体中包含一个数据域和一个指向下一个节点的指针域。具体实现如下：

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

Node *createLinkedList(int arr[], int n) {
    Node *head = NULL, *tail = NULL;
    for (int i = 0; i < n; i++) {
        Node *node = (Node *)malloc(sizeof(Node));
        node->data = arr[i];
        node->next = NULL;
        if (head == NULL) {
            head = tail = node;
        } else {
            tail->next = node;
            tail = node;
        }
    }
    return head;
}

2. 实现单链表的插入：

单链表的插入可以通过先找到要插入的位置，然后将新节点插入到该位置之后来实现。具体实现如下：

void insertNode(Node *head, int pos, int data) {
    Node *node = (Node *)malloc(sizeof(Node));
    node->data = data;
    node->next = NULL;
    Node *p = head;
    for (int i = 1; i < pos && p != NULL; i++) {
        p = p->next;
    }
    if (p != NULL) {
        node->next = p->next;
        p->next = node;
    }
}

3. 实现单链表的删除：

单链表的删除可以通过先找到要删除的节点，然后将该节点从链表中删除来实现。具体实现如下：

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

4. 实现单链表的查找：

单链表的查找可以通过遍历链表，逐个比较节点的数据域来实现。具体实现如下：

Node *searchNode(Node *head, int data) {
    Node *p = head;
    while (p != NULL && p->data != data) {
        p = p->next;
    }
    return p;
}

5. 实现单链表的显示：

单链表的显示可以通过遍历链表，逐个输出节点的数据域来实现。具体实现如下：

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

6. 两个线性表合并算法的实现：

两个线性表合并可以通过定义一个新的顺序表，然后逐个比较LA和LB中的元素，将较小的元素插入到新的顺序表中，直到LA和LB中的元素都被插入到新的顺序表中。具体实现如下：

void merge(int LA[], int LB[], int LC[], int n, int m) {
    int i = 0, j = 0, k = 0;
    while (i < n && j < m) {
        if (LA[i] <= LB[j]) {
            LC[k++] = LA[i++];
        } else {
            LC[k++] = LB[j++];
        }
    }
    while (i < n) {
        LC[k++] = LA[i++];
    }
    while (j < m) {
        LC[k++] = LB[j++];
    }
}

完整代码如下：