C语言已知指针LA和LB分别指向两个无头结点单链表的首元结点。要求编一算法实现，从表LA中删除自第i个元素起共len个元素后，将它们插入到表LB中第j个元素之前。

下面是一份C语言代码，可以实现该算法：

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

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

void deleteAndInsert(Node* LA, Node* LB, int i, int len, int j) {
    // 找到第 i 个结点的前驱结点
    Node* p = LA;
    for (int k = 1; k < i; k++) {
        if (p == NULL) {
            printf("Error: LA list is too short.\n");
            return;
        }
        p = p->next;
    }

    // 找到第 i + len - 1 个结点
    Node* q = p;
    for (int k = 1; k < len; k++) {
        if (q == NULL) {
            printf("Error: LA list is too short.\n");
            return;
        }
        q = q->next;
    }

    // 删除 LA 中的这些结点，并保存它们的头尾指针
    Node* delHead = p->next;
    Node* delTail = q;
    p->next = q->next;
    q->next = NULL;

    // 找到 LB 中第 j 个结点的前驱结点
    p = LB;
    for (int k = 1; k < j; k++) {
        if (p == NULL) {
            printf("Error: LB list is too short.\n");
            return;
        }
        p = p->next;
    }

    // 将这些结点插入到 LB 中
    if (p == NULL) {
        LB->next = delHead;
    } else {
        Node* q = p->next;
        p->next = delHead;
        delTail->next = q;
    }
}

int main() {
    // 构造 LA 和 LB 两个链表
    Node* LA = (Node*)malloc(sizeof(Node));
    LA->next = NULL;
    Node* p = LA;
    for (int i = 1; i <= 5; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        p->next = node;
        p = node;
    }

    Node* LB = (Node*)malloc(sizeof(Node));
    LB->next = NULL;
    p = LB;
    for (int i = 6; i <= 10; i++) {
        Node* node = (Node*)malloc(sizeof(Node));
        node->data = i;
        node->next = NULL;
        p->next = node;
        p = node;
    }

    // 执行删除和插入操作
    deleteAndInsert(LA, LB, 2, 3, 4);

    // 输出结果
    printf("LA: ");
    p = LA->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    printf("LB: ");
    p = LB->next;
    while (p != NULL) {
        printf("%d ", p->data);
        p = p->next;
    }
    printf("\n");

    // 释放内存
    p = LA;
    while (p != NULL) {
        Node* q = p->next;
        free(p);
        p = q;
    }

    p = LB;
    while (p != NULL) {
        Node* q = p->next;
        free(p);
        p = q;
    }

    return 0;
}

这段代码中，我们首先构造了两个链表 LA 和 LB，然后调用 `deleteAndInsert` 函数执行删除和插入操作，最后输出结果并释放内存。函数中的具体实现如下：

1. 首先，我们找到 LA 中第 i 个结点的前驱结点 p，以及第 i+len-1 个结点 q。如果 LA 的长度不足 i+ len，则说明操作非法，直接返回。
2. 然后，我们删除 LA 中这些结点，并保留它们的头尾指针 delHead 和 delTail。
3. 接下来，我们找到 LB 中第 j 个结点的前驱结点 p。如果 LB 的长度不足 j，则说明操作非法，直接返回。
4. 最后，我们将这些结点插入到 LB 中：将 delHead 插入到 p 和 p->next 之间，将 delTail 插入到 delHead 和 p->next 之间。

需要注意的是，由于 LA 和 LB 都是无头结点的单链表，因此在插入结点时，需要特别处理 LB 为空的情况。如果 LB 为空，则直接将 delHead 插入到 LB 中即可。