数据结构的串小解

最新推荐文章于 2021-10-24 21:29:12 发布

LGUOQING

最新推荐文章于 2021-10-24 21:29:12 发布

阅读量198

点赞数 1

分类专栏： C++\C

本文链接：https://blog.csdn.net/LGUOQING/article/details/106575198

版权

C++\C 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

此次结构是串，学过Java都知道string类，这是Java有别于C的一点，Java没有数组，于是有了string类来填补空洞。
string类是一个连续的字符串，所以这篇文章的串就是string类的基础，string类的原理，以及它的构造成分。

对于这篇文章我有两点要说的：
1、我为了方便新手看，我会拿string类来作比较的讲解，因此我也会直接说我在写string类。但是，我这只是方便理解，但我写的不是string，只是说从根本上看，从我写的那些功能上看，string类是都有的。
2、我用的是c，这也是大多数学校普遍选择的语言。因此我们会涉及到指针——C的精华。我也写了一篇关于指针的文章，讲解了一丢丢浅显的、相关的东西，那篇文章里面有个链接是我个人觉得不错的一个B站视频，对指针讲解我觉得蛮透彻的。
/------------------------------------------------------------------------------/
言归正传
首先，我们需要cpp的头文件，一个宏定义，还有一个结构体，：

#include <iostream>
#define MAXLEN 100

using namespace std;
typedef struct Bunch{
	char data[MAXLEN];
	int len;
}bunch;

讲解：宏定义用来定义串中字符数组的大小，我一般给100。结构体中，存放字符数据的是一个字符性的数组，因为我们要写的是string类，所以存放的数据是数组，再给个len，我方便使用，就写了简写，你也可以写完整的单词，而这个东西是用来计算你存放了多少个字符的，也就相当于string类常用方法——length计算字符长度，待会放值时，放一个，len就要自增一位。

然后我们要给这个string方法初始化，你才能使用它，因此我们要初始化我们的方法：

//初始化 
bunch *CreateBunch(){
	bunch *B;
	B = new bunch; 
	B->len=0;
	return B;
}

讲解：其实这个初始化非常好理解。我的结构体有两个变量，一个放值——data，一个计算长度——len。我的变量data是个数组，在结构体中定义的时候就已经被分配了空间，但是，它的长度变量len没有初始值，如果我没有存值进去就查看长度，可能会随机整个数给你，这就不对了。所以初始化就是将len变量赋一个初值。一般是0，表示串中没有字符。

接着就是功能了。我分为两块，一块基础功能，也就是必要的功能，关系到你的串能够正常运行的，即存值、取值、读值；另一块是扩展功能，比如string类的 equals——判断字符串是否相同、substring——截取字符串、substr——截取字符串、trim——忽略字符串头尾的空格等等功能，我更喜欢叫做方法。
基础功能：

//串空
bool IsEmpty(bunch *B){
	if(B->len == 0)
		return true;
	else
		return false;
}

//串满 
bool IsFull(bunch *B){
	if(B->len == MAXLEN)
		return true;
	else
		return false;
}

 //输出
void OutBunch(bunch *B){
	int i=0;
	printf("\n串值：");
	puts(B->data);
	printf("\n"); 
	return ;
}

//长度
int LenBunch(bunch *B){
	while(B->data[B->len] != '\0'){
		++B->len;
	}
	return B->len;
} 
//输入 
void InBunch(bunch *B){
	if(IsFull(B)){
		printf("满了！！\n");
		return ;
	}
	printf("\n请输入串值：");
	gets(B->data);
	LenBunch(B);
	return ; 
}

讲解：这就是基础功能，无论你什么功能，你首先都要判断一下串空、满与否，要用到IsFull——串满、IsEmpty——串空/再就是你的串内放值、读取串内的值，就要有InBunch——输入、OutBunch——输出，还有一个串长——LenBunch。这里的功能名字可以自己定义，我是因为上面代码用的这个名字。

然后我在简单的放两个方法：删除、插入，这是经常要用的方法。

删除：

 //子串删除 
void deleteBunch(bunch *B1, int start, int end){
  	if(B1->data[0] == '\0' ){
 		printf("串不存在！！\n");
  	 	return ;
  	}
  	if(B1->len <end ||B1->len < start){
  		printf("串越界了！！\n");
  	 	return ;
	}
	int j=start-1;
	for(int i=0; i<B1->len-start-end+1; i++){
		B1->data[j] = B1->data[i+start+end-1];
		j++;
	}
	B1->data[j] = '\0';
  }

//删除子串
void DeleteBunch(){
	printf("删除子串！！\n");
	int start,end;
	 printf("删除子串！！\n");
	 printf("输入第一个坐标：");
	 scanf("%d",&start);
	 printf("输入第二个坐标：");
	 scanf("%d",&end);
	deleteBunch(B1,start,end);
}

讲解：其实就是给你东西，你按照给的找到要删除的数据进行删除操作。我的是分为两块，一块是输入你想要删除的数据，有的是输入项删除的值、字段，有的是给你位置，找到后删除。我的是给两个坐标，将坐标内的删掉。另一块是实现功能，当你不想用按坐标查询删除时，我可以改成按值删除，这样方便调试、更改。

插入：

  //子串插入
  void InsertBunch(bunch *B2, bunch *B3, int place){//主串、子串、位置 
  	 if(B2->data[0] == '\0' || B3->data[0] == '\0'){
  	 	printf("串不存在！！\n");
  	 	return ;
  	}
  	if(B2->len+B3->len-1 > MAXLEN || place > B2->len){
  		printf("越界，不能插入！！"); 
  		return ;
	  }
  	//将主串的规定地点后的东西全给子串 
  	for(int i=place; i<B2->len; i++){
  		B3->data[B3->len] = B2->data[i];
  		B3->len++;
	}
	B3->data[B3->len]='\0';
	//再将子串全给主串 
	int j=place;
	for(int i=0; i<B3->len+1; i++) {
		B2->data[j] = B3->data[i];
		j++;
	}
	LenBunch(B2);
	return ;
  }

//插入子串	
	printf("插入子串！！\n");
	printf("\n插入到第三个数据后！\n"); 
	InsertBunch(B1,B2,3);
	OutBunch(B1);

讲解，插入也是，有的是按坐标插入，有的是插入到某值的相对位置。我用的是给定位置插入值。

//----------------------------------------------------------------------------------------------------------------------------------------------------------//
具体的代码，完整的：

#include <iostream>
#define MAXLEN 100

using namespace std;
typedef struct Bunch{
	char data[MAXLEN];
	int len;
}bunch;

//初始化 
bunch *CreateBunch(){
	bunch *B;
	B = new bunch; 
	B->len=0;
	return B;
}
//串空
bool IsEmpty(bunch *B){
	if(B->len == 0)
		return true;
	else
		return false;
}

//串满 
bool IsFull(bunch *B){
	if(B->len == MAXLEN)
		return true;
	else
		return false;
}

 //输出
void OutBunch(bunch *B){
	int i=0;
	printf("\n串值：");
	puts(B->data);
	printf("\n"); 
	return ;
}

//长度
int LenBunch(bunch *B){
	while(B->data[B->len] != '\0'){
		++B->len;
	}
	return B->len;
} 

 //串比较
 bool EqualBunch(bunch *B1, bunch *B2){
 	int i;
 	for(i=0; B1->data[i] == B2->data[i] && B1->data[i] && B2->data[i]; i++)
 	;
 	if(B1->data[i] == B2->data[i])
		return true;
	else
		return false;
 }
 
//求子串——从下标为start（最小为1）的数据开始，往后数end（最大为Len-1）个数据   
void SubBunch(bunch *B3, bunch *B1){
	if(B1->len == 0 || B1->data[0] == '\0'){
		printf("串B1不存在！！");
	}
	
	 int start;
	 int end;
	 int x,y;
	printf("\n说明：从下标为start（最小为1）的数据开始，往后数end（最大为Len-1）个数据 ！！\n");
	
	while(1){
		printf("\n请输入start的值："); 
		scanf("%d",&start);
		if(start>=1 && start<=B1->len-1){
			break;
		}else{
			printf("输入越界！！\n");
		}
	}
	while(1){
		printf("\n请输入end的值：");
		scanf("%d",&end);
		if(end>=1 && end<=B1->len-1){
			break;
		}else{
			printf("输入越界！！\n");
		}
	}
	
	 
	 //实现的具体功能 
	 for(x=0; x<end; x++){
	 	B3->data[x] = B1->data[start-1+x];
	 }
	 B3->data[++x] = '\0';
	 LenBunch(B3);
	 return ; 
} 

 
 //链接串
 void linkBunch(bunch *B1, bunch *B2){
 	if((B1->len+B2->len) > MAXLEN){
 		printf("连接的串总长越界了！！\n");
 		return ;
	 }
	 int i = 0;
	 while(B2->data[i] != '\0'){
	 	B1->data[B1->len++] = B2->data[i++];
	 }
	 B1->data[B1->len] = '\0';
	 OutBunch(B1);
 	
 }
  //子串插入
  void InsertBunch(bunch *B2, bunch *B3, int place){//主串、子串、位置 
  	 if(B2->data[0] == '\0' || B3->data[0] == '\0'){
  	 	printf("串不存在！！\n");
  	 	return ;
  	}
  	if(B2->len+B3->len-1 > MAXLEN || place > B2->len){
  		printf("越界，不能插入！！"); 
  		return ;
	  }
  	//将主串的规定地点后的东西全给子串 
  	for(int i=place; i<B2->len; i++){
  		B3->data[B3->len] = B2->data[i];
  		B3->len++;
	}
	B3->data[B3->len]='\0';
	//再将子串全给主串 
	int j=place;
	for(int i=0; i<B3->len+1; i++) {
		B2->data[j] = B3->data[i];
		j++;
	}
	LenBunch(B2);
	return ;
  }
 //子串删除 
void DeleteBunch(bunch *B1, int start, int end){
  	if(B1->data[0] == '\0' ){
 		printf("串不存在！！\n");
  	 	return ;
  	}
  	if(B1->len <end ||B1->len < start){
  		printf("串越界了！！\n");
  	 	return ;
	}
	int j=start-1;
	for(int i=0; i<B1->len-start-end+1; i++){
		B1->data[j] = B1->data[i+start+end-1];
		j++;
	}
	B1->data[j] = '\0';
	puts(B1->data);
  }
  
  
//输入 
void InBunch(bunch *B){
	if(IsFull(B)){
		printf("满了！！\n");
		return ;
	}
	printf("\n请输入串值：");
	gets(B->data);
	LenBunch(B);
	return ; 
}

int main(){
	bunch *B1,*B2;
	bunch *B3;
	B1 = CreateBunch();
	B2 = CreateBunch();
	B3 = CreateBunch();
	
	//输入 
	printf("输入串B1\n");
	InBunch(B1);
	printf("输入串B2\n");
	InBunch(B2);
	
	//输出 
	printf("主：");
	OutBunch(B1);
	printf("子："); 
	OutBunch(B2);

	//串长
	printf("\n串B1的长度为：%d\n",LenBunch(B1));
	printf("\n串B2的长度为：%d\n",LenBunch(B2));
	
	//链接串
	printf("链接串！！\n");
	linkBunch(B1,B2);
	
	//串长
	printf("\n新串B1的长度为：%d\n",LenBunch(B1));
	 
	//求子串
	printf("求子串！！\n");
	SubBunch(B3,B1);
	printf("\n子串B3的长度为：%d\n",LenBunch(B3));
	OutBunch(B3);
	
	//串比较
	printf("串比较！！\n");
	if(EqualBunch(B1,B2)){
		printf("两个字符串是相等的！！\n");
	}
	else{
		printf("两个字符串不相等的！！\n");
	}
	
	//插入子串	
	printf("插入子串！！\n");
	printf("\n插入到第三个数据后！\n"); 
	InsertBunch(B1,B2,3);
	OutBunch(B1);
	
	//删除子串
	printf("删除子串！！\n");
	int start,end;
	 printf("删除子串！！\n");
	 printf("输入第一个坐标：");
	 scanf("%d",&start);
	 printf("输入第二个坐标：");
	 scanf("%d",&end);
	 DeleteBunch(B1,start,end);
}

LGUOQING

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构的串小解

此次结构是串，学过Java都知道string类，这是Java有别于C的一点，Java没有数组，于是有了string类来填补空洞。string类是一个连续的字符串，所以这篇文章的串就是string类的基础，string类的原理，以及它的构造成分。对于这篇文章我有两点要说的：1、我为了方便新手看，我会拿string类来作比较的讲解，因此我也会直接说我在写string类。但是，我这只是方便理解，但我写的不是string，只是说从根本上看，从我写的那些功能上看，string类是都有的。2、我用的是c，这也是
复制链接

扫一扫