设计实现链串创建、指定位置插入串、删除指定位置指定长度的子串、串的连接操作。

### 回答1：
链串的创建可以通过定义一个结构体来实现，结构体中包含一个字符数组和一个指向下一个结构体的指针，每次插入字符时，新建一个结构体并将其指针赋值给上一个结构体的指针域。

指定位置插入串可以先找到要插入的位置，然后将原串中该位置后面的字符依次后移，再将要插入的串插入到空出来的位置中。

删除指定位置指定长度的子串可以先找到要删除的位置，然后将该位置后面的字符依次前移，直到删除指定长度的子串为止。

串的连接操作可以先找到第一个串的末尾，然后将第二个串中的字符依次插入到第一个串的末尾。

### 回答2：
链串是一种用链表实现的字符串，由若干个节点组成，每个节点包含一个字符和一个指向下一个节点的指针。链串相比于数组串，具有动态性和灵活性，不需要预设大小，可以根据需要动态分配节点。

链串创建操作：链串的创建很简单，只需要逐一给每个节点赋值即可。为了方便起见，通常会新建一个头结点来作为链表的起点，头结点的字符可以为空。创建链串的代码如下：

typedef struct LNode
{
    char data;
    struct LNode *next;
}LNode, *LinkStr;
 
LinkStr createLinkStr(char *str)
{
    LinkStr head, tail, p;
    head = (LinkStr)malloc(sizeof(LNode));
    head->next = NULL;
    tail = head;
    while (*str)
    {
        p = (LinkStr)malloc(sizeof(LNode));
        p->data = *str++;
        p->next = NULL;
        tail->next = p;
        tail = p;
    }
    return head;
}

指定位置插入串操作：将一个串插入到另一个串中指定位置，可以分为两个步骤：先将指定位置前面的子串保存下来，然后将要插入的串拼接在后面即可。代码如下：

void linkStrInsert(LinkStr s, int pos, LinkStr t)
{
    LinkStr p = s, q = t->next, r;
    int i;
    for (i = 1; i < pos && p != NULL; i++)
    {
        p = p->next;
    }
    if (p == NULL)
    {
        printf("插入位置非法！\n");
        return;
    }
    r = p->next;
    p->next = q;
    while (q->next != NULL)
    {
        q = q->next;
    }
    q->next = r;
}

删除指定位置指定长度的子串操作：类似于插入操作，先找到要删除的子串的前面一个节点和后面一个节点，然后将要删除的节点逐一释放即可。代码如下：

void linkStrDelete(LinkStr s, int pos, int len)
{
    LinkStr p = s, q;
    int i;
    for (i = 1; i < pos && p->next != NULL; i++)
    {
        p = p->next;
    }
    if (p->next == NULL)
    {
        printf("删除位置非法！\n");
        return;
    }
    q = p->next;
    for (i = 0; i < len && q->next != NULL; i++)
    {
        LinkStr tmp = q;
        q = q->next;
        free(tmp);
    }
    p->next = q;
}

串的连接操作：将两个串拼接在一起，只需要找到第一个串的最后一个节点，在其后面将第二个串逐一连接即可。代码如下：

void linkStrConcat(LinkStr s, LinkStr t)
{
    LinkStr p = s;
    while (p->next != NULL)
    {
        p = p->next;
    }
    p->next = t->next;
    free(t);
}

以上即是链串的四个基本操作：创建、指定位置插入、删除指定位置指定长度的子串和连接操作。需要注意的是，在进行插入和删除操作时，要注意边界的判断，避免出现越界的情况。

### 回答3：
链串是指用链表结构实现的字符串，它比较常见的应用就是文本编辑器中的缓存区。本文将介绍链串的四个基本操作：链串创建、指定位置插入串、删除指定位置指定长度的子串、串的连接操作。

链串的创建

链串的创建通常需要提供一个字符串作为初始值。创建过程可以通过遍历字符串，在每个字符后面添加一个节点来实现。具体实现可以参考下面的代码：

typedef struct node{
    char ch;
    struct node *next;
}Node, *List;

List Create(char *str)
{
    List l = (List)malloc(sizeof(Node));
    l->next = NULL;
    Node *tail = l;
    while(*str)
    {
        Node *p = (Node*)malloc(sizeof(Node));
        p->ch = *str;
        tail->next = p;
        tail = p;
        str++;
    }
    tail->next = NULL;
    return l;
}

指定位置插入串

在链串中，插入操作通常是指在指定位置插入一个字符串。实现起来比较麻烦，需要先找到要插入的位置，然后将后面的节点都向后移动，并且需要注意边界情况。具体实现可以参考下面的代码：

List Insert(List l, char *str, int pos)
{
    int len = 0;
    Node *p = l->next;
    while(p)
    {
        ++len;
        if(len==pos)
            break;
        p = p->next;
    }
    if(!p)
        return l;

    Node *q = p->next;
    while(*str)
    {
        Node *t = (Node*)malloc(sizeof(Node));
        t->ch = *str;
        p->next = t;
        p = t;
        str++;
    }
    p->next = q;
    return l;
}

删除指定位置指定长度的子串

在链串中，删除操作通常是指删除指定位置开始，指定长度的字符。这个过程也比较麻烦，需要先找到要删除的位置，然后遍历要删除的节点，将其从链表上删除，并释放空间。具体实现可以参考下面的代码：

List Delete(List l, int pos, int len)
{
    Node *p = l->next;
    int i = 1; // 计数器
    while(p && i<pos)
    {
        p = p->next;
        i++;
    }
    if(!p) // 如果没找到位置，直接返回原链表
        return l;

    Node *q = p->next;
    i = 0; // 计数器清零
    while(q && i<len)
    {
        Node *t = q;
        q = q->next;
        free(t);
        i++;
    }
    p->next = q;
    return l;
}

串的连接操作

在链串中，连接操作也比较麻烦，需要找到第一个串的尾节点，然后将其next指针指向第二个串的头节点。具体实现可以参考下面的代码：

List Concat(List l1, List l2)
{
    Node *p = l1->next;
    while(p->next)
        p = p->next;
    p->next = l2->next;
    return l1;
}

总结

链串实现起来比较麻烦，需要考虑边界情况和指针的移动。但是它的优点是可以动态地增加和删除字符，而且内存使用更加灵活。同时，链串也为后续的字符串操作提供了基础。