线性表的链式存储实现 单链表的插入、删除、查找、求表长、置逆以及有序单链表的合并算法的实现。

单链表的链式存储实现：

定义一个结构体表示单链表中的一个结点，包含数据域和指向下一个结点的指针：

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

其中，`LinkedList` 表示单链表的头指针。

插入操作：

在单链表的第 i 个位置插入一个元素：

bool insert(LinkedList L, int i, int x) {
    Node *pre = L;
    for (int j = 1; j < i && pre; j++) {
        pre = pre->next;
    }
    if (!pre) {
        return false;
    }
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = x;
    newNode->next = pre->next;
    pre->next = newNode;
    return true;
}

删除操作：

删除单链表的第 i 个元素：

bool delete(LinkedList L, int i) {
    Node *pre = L;
    for (int j = 1; j < i && pre; j++) {
        pre = pre->next;
    }
    if (!pre || !pre->next) {
        return false;
    }
    Node *delNode = pre->next;
    pre->next = delNode->next;
    free(delNode);
    return true;
}

查找操作：

在单链表中查找值为 x 的元素位置：

int find(LinkedList L, int x) {
    Node *p = L->next;
    int i = 1;
    while (p) {
        if (p->data == x) {
            return i;
        }
        p = p->next;
        i++;
    }
    return -1;
}

求表长操作：

int length(LinkedList L) {
    Node *p = L->next;
    int len = 0;
    while (p) {
        len++;
        p = p->next;
    }
    return len;
}

置逆操作：

将单链表置逆：

void reverse(LinkedList L) {
    if (!L->next || !L->next->next) {
        return;
    }
    Node *p = L->next->next, *q;
    L->next->next = NULL;
    while (p) {
        q = p->next;
        p->next = L->next;
        L->next = p;
        p = q;
    }
}

有序单链表的合并算法实现：

将两个有序单链表 A 和 B 合并成一个有序单链表 C：

LinkedList merge(LinkedList A, LinkedList B) {
    Node *p = A->next, *q = B->next, *r, *s;
    LinkedList C = (LinkedList)malloc(sizeof(Node));
    C->next = NULL;
    r = C;
    while (p && q) {
        if (p->data <= q->data) {
            s = p;
            p = p->next;
        } else {
            s = q;
            q = q->next;
        }
        r->next = s;
        r = s;
    }
    r->next = p ? p : q;
    return C;
}