串

最新推荐文章于 2022-10-12 00:45:00 发布
最新推荐文章于 2022-10-12 00:45:00 发布
阅读量627 收藏 1
点赞数 1
分类专栏： 数据结构和基本算法 文章标签： 数据结构 串
本文为博主原创文章，转载请务必附上文章网址，谢谢。
本文链接：https://blog.csdn.net/zjw_python/article/details/71775017
版权

1.基本概念

由零个或多个字符组成的有限序列。

2.抽象数据类型（ADT）

数据对象：串的数据对象约束为字符集

数据关系：与线性表类似，除第一个和最后一个元素外，其余元素有且仅有一个直接前驱和直接后驱。

基本操作：

                   StrAssign(*T, chars): 生成一个其值等于chars的串T。

                   StrCopy(*T, S): 由串S复制得串T。

                   StrEmpty(S):若串S为空串，则返回TRUE，否则返回FALSE。

                   StrCompare(S, T): 若S>T，则返回值为1；若S=T，则返回值为0；若S<T，则返回值为-1。

                   StrLength(S): 返回串S的元素个数。

                   ClearString(*S): 清空S。

                   Contact(*T, S1, S2): 用T返回由S1和S2联接而成的新串。

                   SubString(*Sub, S, pos, len): 用Sub返回串S的第pos个字符起长度为len的子串。

                   Index(S, T, pos): 若主串S中存在与非空串T值相同的子串，则返回它在主串中第pos个字符之后第一次出现的位置；否则返回0。

                  Replace(*S ,T ,V): 用V替换主串S中出现的所有与T相等的不重叠的子串。

                  StrInsert(*S, pos, T): 在串S的第pos个字符之前插入串T。

                  StrDelete(*S, pos, len): 从串S中删除第pos个字符起长度为len的子串。

3.顺序存储

串的顺序存储方式可以用定长数组存储表示，也可以用堆分配存储表示。两者都具有顺序存储结构的特点，处理方便，但前者有个缺陷，由于数组长度限定，可能会出现数据溢出的错误。因此相比之下，第二种方法更为灵活。在此主要介绍堆分配存储方式。

#define ERROR 0
#define OK 1
#define TRUE 1
#define FALSE 0
#include <stdlib.h>
#include <stdio.h>
#define MAXSIZE 100 
//串的堆分配存储表示
typedef struct
{
	char*ch;           //串的存储基地址 
	int length;	      //串的长度 
}HString;

int StrAssign(HString*T,char *chars)    //新建串 
{
	int i=0;
	char*c=chars;
	if (T->ch) free(T->ch);
	while (*c)
	{
		c++;
		i++;
	}
	T->length=i;      //确定字符串长度      
	if (i==0) 
	{
		T->ch=NULL;
	}else
	{
		if (!(T->ch=(char*)malloc(sizeof(char)*(i+1)))) return ERROR;     //申请存储空间，多预留一个空间，用于放置结束符号'\0'，方便之后输出 
		for (i=0;i<T->length;i++)
		{
			T->ch[i]=chars[i];
		}
		T->ch[i]='\0';	
	}
	return OK;
}

int StrCopy(HString*T,char*S)   //复制串 
{
	int i=0,j;
	char*c=S;
	while (*c)
	{
		c++;
		i++;
	}
	if (T->ch) free(T->ch);
	if (!(T->ch=(char*)malloc(sizeof(char)*i+1))) return ERROR;    //申请存储空间，多预留一个空间，用于放置结束符号'\0'，方便之后输出 
	for (j=0;j<i;j++)               //逐个字符复制 
	{
		T->ch[j]=S[j];
	} 
	T->length=i;
	T->ch[j]='\0';
	return OK;
}

int StrEmpty(HString S)   //验证串是否为空 
{
	if (S.length==0) return TRUE;
	return FALSE;
}

int StrLength(HString S)  //返回串长度 
{
	return S.length;
}

int ClearString(HString *S)  //清空串 
{
	if (S->ch) 
	{
		free(S->ch);
		S->ch=NULL;
	}
	S->length=0;
	return OK;
}

int StrCompare(HString S,HString T)  //比较两个串的大小 
{
	int i;
	for (i=0;i<S.length && i<T.length;i++)
	{
		if (S.ch[i]>T.ch[i]) return 1;
		if (S.ch[i]<T.ch[i]) return -1;
	}
	if (S.length>T.length) i=1;
	else if (S.length<T.length) i=-1;
	else i=0;
	return i;
} 

int Contact(HString*T,HString S1,HString S2)  //连接两个串 
{
	int i,j;
	if (T->ch) free(T->ch);
	if (!(T->ch=(char*)malloc(sizeof(char)*(S1.length+S2.length+1)))) return ERROR;
	for (i=0;i<S1.length;i++) T->ch[i]=S1.ch[i];   //首先粘贴第一个串 
	for (j=0;j<S2.length;j++) T->ch[i+j]=S2.ch[j];  //接着粘贴第二个串 
	T->ch[i+j]='\0';
	T->length=S1.length+S2.length;
}

int SubString(HString*Sub,HString S,int pos,int len)    //取子串 
{
	int i;
	if (pos<1 || pos>S.length || len<0 || len>(S.length-pos+1))   //若取串的位置或长度不合法，则返回错误 
	return ERROR;
	if (Sub->ch) free(Sub->ch);
	if (!(Sub->ch=(char*)malloc(sizeof(char)*(len+1)))) return ERROR;
	for (i=0;i<len;i++)
	{
		Sub->ch[i]=S.ch[pos+i-1];          
	}
	Sub->ch[i]='\0';
	Sub->length=len;
	return OK; 
}

int Index(HString S,HString T,int pos)   //查找子串位置 
{
	int i,j;
	if (pos<1 || pos>S.length || T.length==0) return ERROR; //若子串为空或查找的起始位置不合理，则返回错误 
	if (T.length>S.length) return FALSE;
	j=pos;
	do{
		for (i=0;i<T.length;i++)         //遍历主串和子串，对比每个元素 
		{
			if (S.ch[j+i-1]!=T.ch[i])   //如果有元素不等，则主串的匹配初始位置加1，并重新开始匹配 
			{j++;break;}
		}
	}while(i<T.length && j<S.length);   //如果查找成功或未找到，则退出循坏 
	if (i>=T.length) return j-pos+1;   //若查找成功，返回从起始位置开始的坐标 
	else return FALSE;
}

int Replace(HString*S,HString T,HString V) //替换子串 
{
	int i,j=1;
	HString s,Sub,str,S1;
	s.ch=NULL;Sub.ch=NULL;str.ch=NULL;S1.ch=NULL;
	s.length=0;Sub.length=0;str.length=0;S1.length=0;
	if ( S->length ==0 || T.length==0) return ERROR;   //如果主串为空或要替换的子串长度为空，则返回错误 
	i=Index(*S,T,j);       //第一次查找被替换子串的位置 
	if (i==0) return FALSE; //如果主串中没有要替换的子串，则返回失败 
	while(i!=0)            //如果有替换的子串 
	{
		SubString(&Sub,*S,j,i-1);   //记录被替换子串前面的串 
		Contact(&s,Sub,V);          //将前面的串和新串相连，完成串的替换 
		Contact(&str,S1,s);        //添加到替换过的串后面 
		StrCopy(&S1,str.ch);
		j+=i+T.length-1;          //重新定位查找位置 
		i=Index(*S,T,j);          //查找下一个被替换子串的位置 
	}
	if (j<=S->length)            //把最后一个替换子串后面的串的内容连接到替换过的串尾部 
	{
		SubString(&Sub,*S,j,S->length-j+1);
		Contact(&str,S1,Sub);
		StrCopy(&S1,str.ch);
	}
	*S=S1;                     //更新原来的串 
	return OK;
}

int StrInsert(HString*S,int pos,HString T)  //插入子串 
{
	HString Sub1,S1,Sub2;
	Sub1.ch=NULL;S1.ch=NULL;Sub2.ch=NULL;
	Sub1.length=0;S1.length=0;Sub2.length=0;
	if (pos<1 || pos>S->length+1 || T.length==0) return ERROR;   //如果插入的子串为空或插入的位置非法，则返回错误 
	SubString(&Sub1,*S,1,pos-1);       //记录插入位置之前的串 
	Contact(&S1,Sub1,T);               //将插入位置前的串和插入的串连接起来 
	SubString(&Sub2,*S,pos,S->length-pos+1);  //记录剩下的串 
	Contact(S,S1,Sub2);              //将剩下的串连接到尾部 
	return OK;
}

int StrDelete(HString*S,int pos,int len)  //删除子串 
{
	HString Sub1,Sub2;
	Sub1.ch=NULL;Sub2.ch=NULL;
	Sub1.length=0;Sub2.length=0;
	Sub1.ch=NULL;Sub2.ch=NULL;
	if (pos<1 || pos>S->length || len>S->length-pos+1) return ERROR;  //如果删除位置不合理或删除的长度超过主串的长度，则返回错误 
	SubString(&Sub1,*S,1,pos-1);             //记录删除位置之前的串 
	SubString(&Sub2,*S,pos+len,S->length-pos-len+1);  //记录删除子串后面的剩余串 
	Contact(S,Sub1,Sub2);   //将前面的串和后面的串相连 
	return OK;
}

int main()  
{  
    HString S,T,Sub,V,S1,S2;
    S.ch=NULL;
    T.ch=NULL;
    Sub.ch=NULL;
    V.ch=NULL;
    S1.ch=NULL;
    S2.ch=NULL;
	char s[MAXSIZE];    
    int pos,choice,len;   
    do{  
        printf("输入操作: 0.退出 1.返回串长度 2.插入串 3.删除串 4.获取子串 5.清空串 6.创建串 7.查找串 8.验证串是否为空 9.替换串 10.连接串 11.比较串 12.复制串\n");  
        scanf("%d",&choice);  
        switch (choice)  
        {  
            case 1:  
            {  
				printf("%d\n",StrLength(S));
                break;  
            }  
            case 2:  
            {
				printf("输入插入的位置\n");
				scanf("%d",&pos);
				printf("输入插入的串\n");
				scanf("%s",s);
				StrAssign(&T,s); 
				StrInsert(&S,pos,T);
				printf("S=%s\n",S.ch);
                break;  
            }  
            case 3:  
            {  
            	printf("输入删除的位置\n");
            	scanf("%d",&pos);
            	printf("输入删除的长度\n");
            	scanf("%d",&len);
				StrDelete(&S,pos,len);
				printf("S=%s\n",S.ch);
                break;  
            }  
            case 4:  
            {
				printf("输入子串的起始位置\n");
            	scanf("%d",&pos);
            	printf("输入子串的长度\n");
            	scanf("%d",&len);  
				SubString(&Sub,S,pos,len);
				printf("Sub=%s\n",Sub.ch);
                break;  
            }  
            case 5:  
            {
				ClearString(&S);
				printf("S=%s\n",S.ch);
                break;  
            }  
            case 6:  
            {
				printf("输入串的内容\n");
				scanf("%s",s);  
				StrAssign(&S,s);
				printf("S=%s\n",S.ch);
                break;  
            }  
            case 7:  
            {
				printf("输入在主串中的起始查找位置\n");
            	scanf("%d",&pos);
				printf("输入查找的子串\n");
				scanf("%s",s);
				StrAssign(&T,s);  
				printf("Index=%d\n",Index(S,T,pos)); 
                break;  
            }
			case 8:
			{
				printf("%d\n",StrEmpty(S));
				break;
			} 
			case 9:
			{
				printf("输入被替换的子串\n");
				scanf("%s",s);
				StrAssign(&T,s);
				printf("输入替换的子串\n");
				scanf("%s",s);
				StrAssign(&V,s);
				Replace(&S,T,V);
				printf("S=%s\n",S.ch);
				break;
			} 
			case 10:
			{
				printf("输入第一个子串\n");
				scanf("%s",s);
				StrAssign(&S1,s);
				printf("输入第二个的子串\n");
				scanf("%s",s);
				StrAssign(&S2,s);
				Contact(&T,S1,S2);
				printf("T=%s\n",T.ch);
				break;
			}
			case 11:
			{
				printf("输入第一个子串\n");
				scanf("%s",s);
				StrAssign(&S1,s);
				printf("输入第二个的子串\n");
				scanf("%s",s);
				StrAssign(&S2,s);
				printf("result=%d\n",StrCompare(S1,S2)); 
				break;
			}
			case 12:
			{
				printf("输入要复制的串\n");
				scanf("%s",s);
				StrCopy(&S,s);
				printf("S=%s\n",S.ch);
				break;
			}
        }  
 	}while(choice!=0);
    return 0;  
}

4.链式存储

串也可以使用链式存储方式进行表示，每个结点可以存放多个字符。链表中的最后一个结点不一定全被串值占满，此时通常不上其他非串值字符。为方便串的连接操作，除头指针外还可附设一个尾指针指示链表中的最后一个结点。链式存储结构的操作与线性表类似，但总体上链式存储结构不如顺序存储结构灵活。


PAT-python-zjw
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
串串
大贝贝壳的博客
01-07 193
统计两个串里所有字符的个数，减一减就行了，把这个当做剪枝条件（爆搜+剪枝） #include&lt;bits/stdc++.h&gt; using namespace std; int n; string s,t; int a,b,c; int p[5010],q[5010],r[5010]; string dfs(int x,int a,int b,int c) { if(x==n+1) ...
第四章：串
张生的博客
07-19 601
4.1串的定义和基本操作 串，即字符串，是由零个或多个字符 组成的有限 序列，一般记为：S=‘a1a2…an’； 其中S是串名，单引号内是串的值； ai可以是字母、数字或其他字符； 串中的字符个数n称为串的长度 ，n=0时的串称为空串。 子串：串中任意个连续的字符组成的子序列。 主串：包含子串的串。 字符在主串中的位置：字符在串中的序号。 子串在主串中的位置：子串的第一个字符在串中的序号。 空串VS空格串：M=’’ VS N=’ ’ 空格占字节 串是一种特殊的线性表，数据元素之间成线性关系 串的数据对象
数据结构——串（小白入门第四天）
qq_50645064的博客
07-19 314
小白自学进阶道路
数据结构-串
小旺的博客
10-12 1567
子串：串中任意个连续的字符组成的子序列主串：包含子串的串字符在主串中的位置：字符在串中的序号子串在主串中的位置：子串的第一个字符在主串中的位置串是一种特殊的线性表，数据元素之间呈线性关系串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）串的基本操作，如增删改查等通常以子串为操作对象StrAssign(&T,chars)：赋值操作。把串T赋值为charsStrCopy(&T,S)：复杂操作。由串S复制得到串TStrEmpty(S)：判空操作。
每日算法_4月12日_03
weixin_45548851的博客
04-14 201
1. 串的重要知识点 （1）串的三种存储结构 顺序存储 eg:String str[100]; 需要注意的是：下标为0的存储单元处存储串的长度 堆存储结构 堆存储方式通常有一个头结点 typedef struct { //自定义一种等同于structXXX的数据类型String node *head; int length; }String; String str; str.he...
【数据结构】串 笔记整理
weixin_51630192的博客
07-30 846
【数据结构】串 笔记整理 串的结构体，串的字符操作，KMP算法详解，子串求解等。
C#串口介绍以及简单串口通信程序设计和实现
04-26
2.发送一行字符串HelloBenXH，直接将针脚的发送和接收链接起来就可以测试了（针脚2 接受数据(RXD) 和3 发出数据(TXD)）直接链接, C#代码实现：采用SerialPort 1.实例化一个SerialPort [csharp] view plain copy 在...
字符串操作代码入门python
08-24
字符串操作代码入门 Python Python 中的字符串操作是编程语言的基础知识之一，字符串是 Python 中最常用的数据类型之一。本文将通过实例代码，详细介绍 Python 中字符串操作的基础知识，包括字符串的基本操作、索引...
如何求字符串里的最长回文子串
12-20
根据它的定义,它从左往右和从右往左的字符串是一样的,所以我们很容易想到,只要设计两个指针,一个在头,一个在尾,每次移动一个位置,分别比较两个指针所指元素是否相等,如果一直到两个指针相遇或相邻,都没有出现不相等...
串数组习题：实现下面函数的功能。函数void insert(char*s,char*t,int pos)将字符串t插入到字符串s中，插入位置为pos。假设分配给字符串s的空间足够让字符串t插入。
01-06
此代码可以正常运行 #include #include // 第一种插入方式， 先把s的pos以后的字符串链接到t上，然后在将t插入到s的pos位置 void insert(char *s, char *t, int pos) { char *p=s, *q = t; int i = 0, lent = 0; if(pos<1) { printf(位置不合理\n); exit(0); } while(*p&&i<pos-1) { p++; i++; } if(*p=='\0') { printf(位置不合理\n); exit(0);
将字符串str1复制为字符串str2的三种解决方法
09-04
以下是对将字符串str1复制为字符串str2的三种解决方法进行了详细的介绍，需要的朋友可以过来参考下，希望对大家有所帮助
Lua 字符串
01-03
Lua 字符串 字符串或串(String)是由数字、字母、下划线组成的一串字符。 Lua 语言中字符串可以使用以下三种方式来表示： 单引号间的一串字符。 双引号间的一串字符。 [[和]]间的一串字符。 以上三种方式的字符串实例...
TCP命令转串口命令实用工具
06-29
TCP命令转串口命令实用工具 通过本工具可以实现tcp命令转串口命令 按钮可以自定义，
matlab数组字符串-几个简单的Matlab字符串样例
01-17
Matlab 数组字符串操作详解 Matlab 作为一款强大的数学运算软件，提供了多种字符串操作方法，在实际应用中，字符串操作是必不可少的一部分，本文将对 Matlab 中的字符串操作进行详细的介绍。 一、创建字符串 在 ...
数据结构中串的基本操作
m0_69917453的博客
09-19 1977
串的基本知识
串的基础知识
ChanCherry的博客
03-12 1691
定义 串：是由0个或多个字符组成的有限序列，又叫字符串。S=‘a1a2…an’(n>=0) 空串：长度n=0的串，不包含任何字符。 空格串：是仅由一个或多个空格组成的串，长度>=1。 子串：串中任意个连续的字符组成的子序列。 主串：包含子串的串相应的称为主串。 位置：字符在序列中的序号，子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。 相等：两个串的长度相等，并且对应位置的...
串的定长顺序存储表示和实现
linlinlin45的博客
03-24 5520
串是零个或多个字符的有限序列，我们可以将其看作是种特殊的线性表，其特殊性在于线性表的数据元素的类型总是字符性，字符串的数据对象约束为字符集。 串的存储方式有三种：定长顺序存储表示、堆分配存储表示、块链存储表示。 本文主要讲解串的定长顺序存储表示及其操作的实现 相关定义及准备 #include<iostream> using namespace std; #define TRUE 1 #...
《数据结构》（C语言版）——串的定长顺序存储表示
prlhnxx的博客
04-05 2333
/* run this program using the console pauser or add your own getch, system("pause") or input loop */ // 用到的库文件 #include &lt;stdio.h&gt; // printf(); scanf() #include &lt;stdlib.h&gt; // exit() #incl...
Python 字符串
最新发布
04-11
Python字符串是一种用于存储和操作文本数据的数据类型。它是由一系列字符组成的，可以包含字母、数字、符号和空格等。在Python中，字符串是不可变的，这意味着一旦创建，就不能修改它的值。 以下是一些关于Python...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值