链串实现建串、输入串、输出串、插入串、删除串、取子串、串连接、串替换、求串长等运算。程序设计

以下是链串的实现，包括建立串、输入串、输出串、插入串、删除串、取子串、串连接、串替换、求串长等运算的程序设计。

链串的结构体定义如下：

typedef struct node{
    char data;
    struct node *next;
}Node, *LinkStr;

其中，`data` 表示链串的字符，`next` 指向下一个字符节点，`LinkStr` 表示链串的类型。

1. 建立串

LinkStr createStr(){
    LinkStr head, tail;
    head = (LinkStr)malloc(sizeof(Node));
    tail = head;
    tail->next = NULL;
    char ch;
    while((ch = getchar()) != '\n'){
        LinkStr temp;
        temp = (LinkStr)malloc(sizeof(Node));
        temp->data = ch;
        temp->next = NULL;
        tail->next = temp;
        tail = temp;
    }
    return head;
}

此函数通过循环读入字符，创建节点并连接成链串，最后返回链串头指针 `head`。

2. 输入串

void strInput(LinkStr head){
    LinkStr p = head->next;
    while(p != NULL){
        scanf("%c", &p->data);
        p = p->next;
    }
}

此函数通过循环遍历链串，读入字符并存储到对应节点中。

3. 输出串

void strOutput(LinkStr head){
    LinkStr p = head->next;
    while(p != NULL){
        printf("%c", p->data);
        p = p->next;
    }
    printf("\n");
}

此函数通过循环遍历链串，输出每个节点的字符。

4. 插入串

void strInsert(LinkStr head, int pos, LinkStr str){
    LinkStr p = head;
    for(int i = 0; i < pos - 1; i++){
        p = p->next;
        if(p == NULL){
            printf("position error");
            return;
        }
    }
    LinkStr q = str->next;
    while(q != NULL){
        LinkStr temp;
        temp = (LinkStr)malloc(sizeof(Node));
        temp->data = q->data;
        temp->next = p->next;
        p->next = temp;
        p = temp;
        q = q->next;
    }
}

此函数通过循环遍历链串，找到插入位置 `pos`，然后将要插入的链串 `str` 中的字符逐个创建节点并插入到链串中。

5. 删除串

void strDelete(LinkStr head, int pos, int len){
    LinkStr p = head;
    for(int i = 0; i < pos - 1; i++){
        p = p->next;
        if(p == NULL){
            printf("position error");
            return;
        }
    }
    LinkStr q = p->next;
    for(int i = 0; i < len; i++){
        if(q == NULL){
            printf("length error");
            return;
        }
        LinkStr temp;
        temp = q;
        q = q->next;
        free(temp);
    }
    p->next = q;
}

此函数通过循环遍历链串，找到删除位置 `pos`，然后删除长度为 `len` 的子串。

6. 取子串

LinkStr subStr(LinkStr head, int pos, int len){
    LinkStr p = head;
    for(int i = 0; i < pos; i++){
        p = p->next;
        if(p == NULL){
            printf("position error");
            return NULL;
        }
    }
    LinkStr subHead, subTail;
    subHead = (LinkStr)malloc(sizeof(Node));
    subTail = subHead;
    subTail->next = NULL;
    for(int i = 0; i < len; i++){
        if(p == NULL){
            printf("length error");
            return NULL;
        }
        LinkStr temp;
        temp = (LinkStr)malloc(sizeof(Node));
        temp->data = p->data;
        temp->next = NULL;
        subTail->next = temp;
        subTail = temp;
        p = p->next;
    }
    return subHead;
}

此函数通过循环遍历链串，找到起始位置 `pos`，然后创建一个新的链串并将长度为 `len` 的子串复制到新链串中，最后返回新链串头指针 `subHead`。

7. 串连接

LinkStr strConcat(LinkStr str1, LinkStr str2){
    LinkStr p = str1;
    while(p->next != NULL){
        p = p->next;
    }
    p->next = str2->next;
    return str1;
}

此函数通过遍历链串 `str1`，找到末尾节点，然后将链串 `str2` 接在其后，最后返回新链串头指针 `str1`。

8. 串替换

void strReplace(LinkStr head, LinkStr sub, int pos, int len){
    LinkStr p = head;
    for(int i = 0; i < pos - 1; i++){
        p = p->next;
        if(p == NULL){
            printf("position error");
            return;
        }
    }
    LinkStr q = p->next;
    for(int i = 0; i < len; i++){
        if(q == NULL){
            printf("length error");
            return;
        }
        LinkStr temp;
        temp = q;
        q = q->next;
        free(temp);
    }
    p->next = sub->next;
    LinkStr subTail = sub;
    while(subTail->next != NULL){
        subTail = subTail->next;
    }
    subTail->next = q;
}

此函数通过循环遍历链串，找到起始位置 `pos`，然后删除长度为 `len` 的子串，并将要替换的链串 `sub` 中的字符逐个创建节点并插入到链串中。

9. 求串长

int strLength(LinkStr head){
    int len = 0;
    LinkStr p = head->next;
    while(p != NULL){
        len++;
        p = p->next;
    }
    return len;
}

此函数通过循环遍历链串，统计节点数目并返回其值。

完整代码如下：