李春葆 上机实验题4——实验题2：实现链串的各种基本运算的算法

实现链串的各种基本运算的算法

一、实验内容

编写一个程序实现链串的各种基本运算，并实现下列功能

(1)建立串s="abcdefghijklmn"和和串s1“xyz"

(2)输出串s
(3)输出串s的长度。
(4)在串s的第9个字符的位置插入串s1而产生串s2。
(5)输出串s2。
(6)删除串s从第2个字符开始的5个字符而产生串s2。
(7)输出串s2。
(8)将串s从第2个字符开始的5个字符替换成串s1而产生串s2。
(9)输出串s2。
(10)提取串s从第2个字符开始的10个字符而产生串s3。
(11)输出串s3。
(12)将串s1和串s2连接起来而产生串s4。

(13)输出串s4。

 

二、实验目的

本实验旨在通过编写一个程序实现链串的各种基本运算，包括建立链串、输出链串、获取链串长度、插入链串、删除字符、替换字符、提取字符以及连接链串等操作。通过这个实验，希望学生能够深入理解链串数据结构的原理和实现方式，并且掌握链串中各种基本运算算法的设计和实现技巧。

 

三、实验设计方案

1. 定义链串结构体
   首先需要定义链串的结构体，包括一个头指针和一个用于存储字符的链表。头指针指向链表的头部。
2. 初始化链串
   可以使用一个空的链表来初始化链串。
3. 输出链串
   可以通过遍历链表，并输出每个字符来实现输出链串的操作。
4. 获取链串长度
   可以通过遍历链表，并统计节点的数量来实现获取链串长度的操作。
5. 插入链串
   可以在指定位置之后遍历原链表，将原链表的节点依次向后移动一位，并将新链表的节点依次插入到指定位置之后。
6. 删除字符
   可以遍历原链表，将指定位置之后的节点依次向后移动一位，并最后将链表的头指针指向新的头部。
7. 替换字符
   可以遍历原链表，将指定位置上的节点的字符替换为新字符。
8. 提取字符
   可以遍历原链表，将指定位置开始的节点提取出来，并输出。
9. 连接链串
   可以将两个链表的头指针指向新的头部，并依次遍历并输出两个链表的节点。
10. 提取子串
    可以遍历原链表，将指定位置开始的指定数量的节点提取出来，并输出。

 

四、代码实现

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


typedef struct snode{
	char data;
	struct snode *next;
}LinkStrNode;

//生成串
void StrAssign(LinkStrNode *&s,char cstr[]){
	int i;
	LinkStrNode *r,*p;
	s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	r=s;
	for(i=0;cstr[i]!='\0';i++){
		p=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		p->data=cstr[i];
		r->next=p;
		r=p;
	}
	r->next=NULL;
} 

//销毁串
void DestroyStr(LinkStrNode *&s){
	LinkStrNode *pre=s,*p=s->next;
	while(p!=NULL){
		free(pre);
		pre=p;
		p=p->next;
	}
	free(pre);
} 

//串的复制
void StrCopy(LinkStrNode *&s,LinkStrNode *t){
	LinkStrNode *p=t->next,*q,*r;
	s=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	r=s;
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;
		r=q;
		p=p->next;
	}
	r->next=NULL;
} 

//判断串相等
bool StrEqual(LinkStrNode *s,LinkStrNode *t){
	LinkStrNode *p=s->next,*q=t->next;
	while(p!=NULL&&q!=NULL&&p->data==q->data){
		p=p->next;
		q=q->next; 
	} 
	if(p==NULL&&q==NULL) return true;
	else return false;
} 

//求串的长
int StrLength(LinkStrNode *s){
	LinkStrNode *p=s->next;
	int count=0;
	while(p!=NULL){
		count++;
		p=p->next; 
	}
	return count; 
} 

//串的连接
LinkStrNode* Concat(LinkStrNode *s,LinkStrNode *t){
	LinkStrNode *str,*p=s->next,*q,*r;
	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	r=str;
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	p=t->next;
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	r->next=NULL;
	return str;
} 

//求子串
LinkStrNode * SubStr(LinkStrNode *s,int i,int j){
	int k;
	LinkStrNode *str,*p=s->next,*q,*r;
	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	str->next=NULL; 
	r=str;
	if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
		return str;
	for(k=1;k<i;k++)
		p=p->next;
	for(k=1;k<=j;k++)
	{
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	r->next=NULL;
	return str;
} 

//子串的插入
LinkStrNode * InsStr(LinkStrNode *s,int i,LinkStrNode *t){
	int k;
	LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	str->next=NULL; 
	r=str;
	if(i<=0||i>StrLength(s)+1)
		return str;
	for(k=1;k<i;k++){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	while(p1!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p1->data;
		r->next=q;r=q;
		p1=p1->next;
	}
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	r->next=NULL; 
	return str; 
}

//子串的删除
LinkStrNode * DelStr(LinkStrNode *s,int i,int j){
	int k;
	LinkStrNode *str,*p=s->next,*q,*r;
	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	str->next=NULL; 
	r=str;
	if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
		return str;
	for(k=1;k<i;k++){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	for(k=0;k<j;k++) p=p->next;
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	r->next=NULL; 
	return str; 
}

//子串的替换
LinkStrNode * InsStr(LinkStrNode *s,int i,int j,LinkStrNode *t){
	int k;
	LinkStrNode *str,*p=s->next,*p1=t->next,*q,*r;
	str=(LinkStrNode *)malloc(sizeof(LinkStrNode));
	str->next=NULL; 
	r=str;
	if(i<=0||i>StrLength(s)||j<0||i+j-1>StrLength(s))
		return str;
	for(k=0;k<i-1;k++){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	for(k=0;k<j;k++) p=p->next;
	while(p1!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p1->data;
		r->next=q;r=q;
		p1=p1->next;
	}
	while(p!=NULL){
		q=(LinkStrNode *)malloc(sizeof(LinkStrNode));
		q->data=p->data;
		r->next=q;r=q;
		p=p->next;
	}
	r->next=NULL; 
	return str; 
} 

//输出串
void DispStr(LinkStrNode *s){
	LinkStrNode *p=s->next;
	while(p!=NULL){
		printf("%c",p->data);
		p=p->next;		
	}
	printf("\n");
} 

int main(){
	LinkStrNode *s,*s1;
	//建立串s,s1
	printf("1、建立串s,s1\n");
	char cstr[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n'};
	char cstr1[]={'x','y','z'};
	StrAssign(s,cstr);
	StrAssign(s1,cstr1); 
	printf("\n");
	//输出串s
	printf("2、输出串s:");
	DispStr(s); 
	printf("\n");
	//输出串s的长度
	printf("3、输出串s的长度：");
	StrLength(s);
	printf("%d",StrLength(s));
	printf("\n");
	//在串s的第9个字符位置插入s1而产生s2
	printf("4、在串s的第9个字符位置插入s1而产生s2");
	LinkStrNode *s2;
	s2=InsStr(s,9,s1);
	//输出s2
	printf("5、输出串s2:");
	DispStr(s2); 
	printf("\n"); 
	//删除串s的第2个字符开始的5个字符而产生的s2
	printf("6、删除串s的第2个字符开始的5个字符而产生的s2"); 
	s2=DelStr(s,2,5);
	printf("\n");
	//输出s2
	printf("7、输出串s2:");
	DispStr(s2); 
	printf("\n");
	//将串s的第二个字符开始的5个字符替换成s1而产生s2
	printf("8、将串s的第二个字符开始的5个字符替换成s1而产生s2"); 
	s2=InsStr(s,2,5,s1);
	printf("\n");
	//输出s2
	printf("9、输出串s2:");
	DispStr(s2); 
	printf("\n");
	//提取串s的第2个字符开始的10个字符而产生串s3
	printf("10、提取串s的第2个字符开始的10个字符而产生串s3");
	LinkStrNode *s3;
	s3=SubStr(s,2,10); 
	printf("\n");
	//输出串s3
	printf("11、输出串s3:");
	DispStr(s3); 
	printf("\n");
	//将串s1与s2连接起来产生串s4
	printf("12、将串s1与s2连接起来产生串s4"); 
	LinkStrNode *s4;
	s4=Concat(s1,s2);
	printf("\n");
	//输出串s4
	printf("13、输出串s4:");
	DispStr(s4); 
	printf("\n");
	return 0;
}

 

五、运行结果