数据结构—顺序串 Ⅵ

已于 2022-03-19 09:29:53 修改
阅读量1.4k 收藏 18
点赞数 3
分类专栏： 计算机技术 文章标签： 数据结构 算法 串 c语言 visual studio
于 2021-08-14 06:19:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42071236/article/details/119573532
版权

目录

数据结构-串(第四章)的整理笔记，若有错误，欢迎指正。

可以参考和对比一下C语言里面的字符串：C语言 字符串

串的基本概念：

  • 串(string)是由零个或多个字符组成的有限序列。
  • 两个串相等当且仅当这两个串的长度相等并且对应位置的字符都相同。
  • 一个串中任意个连续字符组成的序列称为该串的子串(substring)。
  • 含零个字符的串称为空串，用∅表示。空串是不包含任何字符的串，其长度为0，空串是任何串的子串。

设S为一个长度为n的字符串，其中的字符各不相同，则S中子串的个数为 n ( n + 1 ) 2 + 1 \frac{n(n+1)}{2}+1 2n(n+1)​+1；
互异非平凡子串(非空且不同于S本身)的个数为 n ( n + 1 ) 2 + 1 − 2 \frac{n(n+1)}{2}+1-2 2n(n+1)​+1−2(减去空串和等于自身的两种情况)= n ( n + 1 ) 2 − 1 \frac{n(n+1)}{2}-1 2n(n+1)​−1

串 的 基 本 操 作 { S t r A s s i g n ( & s , c s t r ) — 生 成 串 D e s t r o y S t r ( & s ) — 销 毁 串 S t r C o p y ( & s , t ) — 串 的 复 制 S t r E q u a l ( s , t ) — 判 断 串 相 等 S t r L e n g t h ( s ) — 求 串 长 C o n c a t ( s , t ) — 串 的 连 接 S u b S t r ( s , i , j ) — 求 子 串 I n s S t r ( s 1 , i , s 2 ) — 子 串 的 插 入 D e l S t r ( s , i , j ) — 子 串 的 删 除 R e p S t r ( s , i , j , t ) — 子 串 的 替 换 D i s p S t r ( s ) — 输 出 串 串的基本操作\begin{cases} StrAssign(\&s, cstr)—生成串\\ DestroyStr(\&s)—销毁串\\ StrCopy(\&s,t)—串的复制\\ StrEqual(s,t)—判断串相等\\ StrLength(s)—求串长\\ Concat(s,t)—串的连接\\ SubStr(s,i,j)—求子串\\ InsStr(s1,i,s2)—子串的插入\\ DelStr(s,i,j)—子串的删除\\ RepStr(s,i,j,t)—子串的替换\\ DispStr(s)—输出串\\ \end{cases} 串的基本操作⎩⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎪⎧​StrAssign(&s,cstr)—生成串DestroyStr(&s)—销毁串StrCopy(&s,t)—串的复制StrEqual(s,t)—判断串相等StrLength(s)—求串长Concat(s,t)—串的连接SubStr(s,i,j)—求子串InsStr(s1,i,s2)—子串的插入DelStr(s,i,j)—子串的删除RepStr(s,i,j,t)—子串的替换DispStr(s)—输出串​


串的顺序存储结构——顺序串

  • 顺序串中的字符被依次存放在一组连续的存储单元里。一般来说，一个字节(8位)可以表示一个字符(存放其ASCII码)。而计算机内存是按字编址的，即以字为存储单位，一个存储单元指的是一个字。而一个字可能包含多个字节，其所包含的字节数随机器而异。
  • 顺序串的存储方式有两种：
    一种是每个字只存一个字符(假设一个字包含4个字节)，这称为非紧缩格式(其存储密度小)。
    在这里插入图片描述
    另ー种是每个字存放多个字符，这称为紧缩格式(其存储密度大)。
    在这里插入图片描述
  • 其中，灰色方块代表字节为空闲。
  • 串的紧缩式节省存储空间，但处理单个字符不太方便，运算效率低，因为需要花费时间从同一个字中分离字符；相反，非紧缩式比较浪费存储空间，但处理单个字符或者一组连续字符方便。

一. 静态分配

类型声明(非紧缩格式)

typedef struct
{
	char data[MaxSize]; //存放字符串字符
	int length; //存放串长
}SqString; //顺序串类型

分析

  • 串的实际长度只能小于等于MaxSize，超过预定义长度的串值会被舍去，称为載断。
  • 串长有两种表示方法：一是如上述定义描述的那样，用一个额外的变量length来存放串的长度；二是在串值后面加一个不计入串长的结東标记字符“\0”，此时的串长为隐含值。

生成串—StrAssign(&s, cstr)

  • 将一个C/C++字符串常量cstr(以"\0"字符标识结尾)赋给顺序串s，即生成一个其值等于cstr的串s。
void StrAssign(SqString &s, char cstr[]) //s为引用型参数
{
	int i;
	for (i = 0; cstr[i] != '\0'; i++)
		s.data[i] = cstr[i];
	s.length = i; //设置串s的长度
}

销毁串— DestroyStr(&s)

void Destroy(SqString &s)
{ }

分析

  • 由于顺序串是直接采用顺序串本身来表示的，而不是顺序串指针，它的存储空间由操作系统管理，即由操作系统分配其存储空间，并在超出作用域时释放其存储空间，所以这里的销毁顺序串运算不包含任何操作。

串的复制—StrCopy(&s,t)

  • 将顺序串t赋值给顺序串s。
void StrCopy(SqString& s, SqString t)
{
	int i;
	for (i = 0; i < t.length; i++) s.data[i] = t.data[i];
	s.length = t.length; //设置串s的长度
}

判断串相等—StrEqual(s,t)

  • 若两个顺序串s与t相等返回真；否则返回假。
bool StrEqual(SqString s, SqString t)
{
	bool same = true;
	int i;
	if (s.length != t.length) same = false; //长度不相等时返回0
	else
		for (i = 0; i < s.length; i++)
			if (s.data[i] != t.data[i]) //有一个对应字符不相同时返回假
			{
				same = false;
				break;
			}
	return same;
}

分析

求串长—StrLength(s)

int StrLength(SqString s)
{ return s.length; }

分析

串的连接—Concat(s,t)

  • 返回由两个顺序串s和t连接在一起形成的结果串。
SqString Concat(SqString s, SqString t)
{
	SqString str; //定义结果串
	int i;
	str.length = s.length + t.length;
	for (i = 0; i < s.length; i++) str.data[i] = s.data[i]; //将s.data[0..s.length-1]复制到str
	for (i = 0; i < t.length; i++) str.data[s.length + i] = t.data[i]; //将t.data[0..t.length-1]复制到str
	return str;
}

分析

求子串—SubStr(s,i,j)

  • 返回顺序串s中从第i(1≤i≤n)个字符开始的由连续j个字符组成的子串。当参数不正确时返回一个空串。
SqString SubStr(SqString s, int i, int j)
{
	int k;
	SqString str; //定义结果串
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = i - 1; k < i + j - 1; k++) str.data[k-i+1] = s.data[k]; //将s.data[i..i+j-1]复制到str
	str.length = j;
	return str;
}

分析

  • 空串是不包含任何字符的串，其长度为0，空串是任何串的子串。

子串的插入—InsStr(s1,i,s2)

  • 将顺序串s2插入到顺序串s1的第i(1≤i≤n+1)个位置上，并返回产生的结果串。当参数不正确时返回一个空串。
SqString InsStr(SqString s1, int i, SqString s2)
{
	int j;
	SqString str; //定义结果串
	str.length = 0; //设置str为空串
	if (i<=0 || i>s1.length+1) return str; //参数不正确时返回空串
	for (j = 0; j < i-1; j++) str.data[j] = s1.data[j]; //将s1.data[0..i-2]复制到str
	for (j = 0; j < s2.length; j++) str.data[i+j-1] = s2.data[j]; //将s2.data[0..s2.length-1]复制到str
	for (j = i-1; j < s1.length; j++) str.data[j + s2.length] = s1.data[j]; //将s1.data[i-1..s1.length-1]复制到str
	str.length = s1.length + s2.length;
	return str;
}

子串的删除—DelStr(s,i,j)

  • 在顺序串s删去从第i(1≤i≤n+1)个字符开始的长度为j的子串，并返回产生的结果串。当参数不正确时返回一个空串。
SqString DelStr(SqString s, int i, int j)
{
	int k = 0;
	SqString str; //定义结果串
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = 0; k < i - 1; k++) str.data[k] = s.data[k]; //将s.data[0..i-2]复制到str
	for (k = i + j - 1; k < s.length; k++) str.data[k - j] = s.data[k]; //将s.data[i+j-1..s.length-1]复制到str
	str.length = s.length - j;
	return str;
}

子串的替换—RepStr(s,i,j,t)

  • 在顺序串s中将第i(1≤i≤n)个字符开始的连续j个字符构成的子串用顺序串t替换并返回产生的结果串。当参数不正确时返回一个空串。
SqString RepStr(SqString s, int i, int j,SqString t)
{
	int k = 0;
	SqString str; //定义结果串
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = 0; k < i - 1; k++) str.data[k] = s.data[k]; //将s.data[0..i-2]复制到str
	for (k = 0; k <t.length ; k++) str.data[i-1+k] = t.data[k]; //将t.data[0..t.length-1]复制到str
	for (k = i + j - 1; k < s.length; k++) str.data[t.length + k - j] = s.data[k]; //将s.data[i+j-1..s.length-1]复制到str
	str.length = s.length - j + t.length;
	return str;
}

输出串—DispStr(s)

  • 输出顺序串s的所有元素值。
void DispStr(SqString s)
{
	int i;
	if (s.length > 0)
		for (i = 0; i < s.length; i++)
			printf("%c", s.data[i]);
}

主函数验证

int main()
{
	SqString s, t, str;
	char cstr1[] = "How are you?";
	//生成串s和t
	printf("-----生成串s和t-----\n");
	StrAssign(s, cstr1);
	printf("s：");
	DispStr(s);
	printf("\ns.length=%d\n", StrLength(s));
	char cstr2[] = "I'm fine.";
	StrAssign(t, cstr2);
	printf("t：");
	DispStr(t);
	printf("\nt.length=%d\n", StrLength(t));

	//串的连接
	printf("\n-----串的连接-----\n");
	str=ConStr(s, t);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//串的复制
	printf("\n-----串的复制-----\n");
	StrCopy(s, t);
	printf("s：");
	DispStr(s);
	printf("\ns.length=%d\n", StrLength(s));

	//判断串相等
	printf("\n-----判断串相等-----\n");
	printf("串s和t相等吗？—%d \n", StrEqual(s,t));

	//求子串
	printf("\n-----求子串-----\n");
	str=SubStr(s, 5, 4);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//子串的删除
	printf("\n-----子串的删除-----\n");
	str = DelStr(s, 5, 3);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//子串的插入
	printf("\n-----子串的插入-----\n");
	str = RepStr(s, 1, 4, t);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	return 0;
}

分析

  • 运行结果：
    在这里插入图片描述

二. 动态分配

  • 在一些串的操作(如插入、连接等)中，若串值序列的长度超过上界MaxSize，约定用“截断”法处理，要克服这种弊端，只能不限定串长的最大长度，即采用动态分配的方式。

完整代码

#include<stdio.h>
#include<malloc.h>
#include<string.h>
#define InitSize 10
typedef char ElemType;
typedef struct
{
	char *data; //存放字符串字符
	int length; //存放串长
	int MaxSize;
}SqString; //顺序串类型

void InitString(SqString &s)
{
	s.data = (char*)malloc(sizeof(char) * InitSize);
	s.MaxSize = InitSize;
}

bool IncreaseSize(SqString& s, int len)
{
	char* p = s.data; //定义整型指针变量，指向队列的首地址
	s.data = (char*)malloc(sizeof(char) * (InitSize + len)); //申请一片更大的连续的存储空间
	for (int i = 0; i < InitSize; i++)
		s.data[i] = p[i]; //将数据复制到新的存储区域中
	s.MaxSize = InitSize + len; //队列的最大长度增加
	free(p); //释放原来的内存空间
	return true;
}

void StrAssign(SqString& s, char cstr[]) //s为引用型参数
{
	int i;
	if (s.MaxSize >= strlen(cstr))
		for (i = 0; cstr[i] != '\0'; i++)
			s.data[i] = cstr[i];
	else
	{
		for (i = 0; i < InitSize; i++)
			s.data[i] = cstr[i];
		IncreaseSize(s, InitSize);
		for (i = InitSize; cstr[i] != '\0'; i++)
			s.data[i] = cstr[i];
	}
	s.length = strlen(cstr); //设置串s的长度
}

void Destroy(SqString &s)
{
	free(s.data);
}

void StrCopy(SqString &s, SqString t)
{
	int i;
	for (i = 0; i < t.length; i++) s.data[i] = t.data[i];
	s.length = t.length; //设置串s的长度
}

bool StrEqual(SqString s, SqString t)
{
	bool same = true;
	int i;
	if (s.length != t.length) same = false; //长度不相等时返回0
	else
		for (i = 0; i < s.length; i++)
			if (s.data[i] != t.data[i]) //有一个对应字符不相同时返回假
			{
				same = false;
				break;
			}
	return same;
}

int StrLength(SqString s)
{
	return s.length;
}

void DispStr(SqString s)
{
	if (s.length > 0)
		for (int i = 0; i < s.length; i++)
			printf("%c", s.data[i]);
}

SqString ConStr(SqString s, SqString t)
{

	SqString str; //定义结果串
	str.data = (char*)malloc(sizeof(char) * (s.length + t.length));
	int i;
	str.length = s.length + t.length;
	for (i = 0; i < s.length; i++) //将s.data[0..s.length-1]复制到str
		str.data[i] = s.data[i];
	for (i = 0; i < t.length; i++) //将t.data[0..s.length-1]复制到str
		str.data[s.length + i] = t.data[i];
	return str;
}

SqString SubStr(SqString s, int i, int j)
{
	int k;
	SqString str; //定义结果串
	str.data = (char*)malloc(sizeof(char)*s.length);
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = i - 1; k < i + j + 1; k++)
		str.data[k - i + 1] = s.data[k]; //将s.data[i..i+j-1]复制到str
	str.length = j;
	return str;
}

SqString InsStr(SqString s1, int i, SqString s2)
{
	int j;
	SqString  str; //定义结果串
	int size = s1.length + s2.length;
	str.data = (char*)malloc(sizeof(char) * size);
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s1.length + 1) return str; //参数不正确时返回空串
	for (j = 0; j < i - 1; j++) //将s1.data[0..i-2]复制到str
		str.data[j] = s1.data[j];
	for (j = 0; j < s2.length; j++) //将s2.data[0..s2.length-1]复制到str
		str.data[i + j - 1] = s2.data[j];
	for (j = i - 1; j < s1.length; j++) //将s1.data[i-1..s1.length-1]复制到str
		str.data[j + s2.length] = s1.data[j];
	str.length = s1.length + s2.length;
	return str;
}

SqString DelStr(SqString s, int i, int j)
{
	int k = 0;
	SqString str; //定义结果串
	str.data = (char*)malloc(sizeof(char) * s.length);
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = 0; k < i - 1; k++) //将s.data[0..i-2]复制到str
		str.data[k] = s.data[k];
	for (k = i + j - 1; k < s.length; k++) //将s.data[i+j-1..s.length-1]复制到str
		str.data[k - j] = s.data[k];
	str.length = s.length - j;
	return str;
}

SqString RepStr(SqString s, int i, int j, SqString t)
{
	int k = 0;
	SqString str; //定义结果串
	int size = s.length + t.length;
	str.data = (char*)malloc(sizeof(char) * size);
	str.length = 0; //设置str为空串
	if (i <= 0 || i > s.length || j<0 || i + j - 1>s.length) return str; //参数不正确时返回空串
	for (k = 0; k < i - 1; k++) //将s.data[0..i-2]复制到str
		str.data[k] = s.data[k];
	for (k = 0; k < t.length; k++)
		str.data[i - 1 + k] = t.data[k];
	for (k = i + j - 1; k < s.length; k++) //将s.data[i+j-1..s.length-1]复制到str
		str.data[t.length + k - j] = s.data[k];
	str.length = s.length - j + t.length;
	return str;
}


int main()
{
	SqString s, t, str;
	InitString(s);
	InitString(t);
	//生成串s和t
	printf("-----生成串s和t-----\n");
	char cstr1[] = "Are you Ok?";
	StrAssign(s, cstr1);
	printf("s：");
	DispStr(s);
	printf("\ns.length=%d\n", StrLength(s));
	char cstr2[] = "Fine,thanks!";
	StrAssign(t, cstr2);
	printf("t：");
	DispStr(t);
	printf("\nt.length=%d\n", StrLength(t));

	//串的连接
	printf("\n-----串的连接-----\n");
	str = ConStr(s, t);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//串的复制
	printf("\n-----串的复制-----\n");
	StrCopy(s, t);
	printf("s：");
	DispStr(s);
	printf("\ns.length=%d\n", StrLength(s));

	//判断串相等
	printf("\n-----判断串相等-----\n");
	printf("串s和t相等吗？—%d \n", StrEqual(s, t));

	//求子串
	printf("\n-----求子串-----\n");
	str = SubStr(s, 6, 4);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//子串的删除
	printf("\n-----子串的删除-----\n");
	str = DelStr(s, 4, 6);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));

	//子串的插入
	printf("\n-----子串的插入-----\n");
	str = RepStr(s, 6, 7, t);
	printf("str：");
	DispStr(str);
	printf("\nstr.length=%d\n", StrLength(str));
	
	return 0;
}

分析

  • 运行结果：
    在这里插入图片描述
—Miss. Z—
关注
  • 3
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言 数据结构】串 - 顺序
懂得一千零一种,赋予你失败的方法！
12-03 2067
串(`String`)：是零个或多个字符组成的有限序列。一般记为： `S='a1a2…an' (n≥0)`。
数据结构顺序串的基本操作（C语言）
多低调的博客
09-23 4775
串的定义 串(string)是零个或多个字符组成的有限序列。一般记为：S="a1a2…an"(n≥0) 其中S是串的名字,用双引号括起来的字符序列是串的值，但双引号是界限符,它不属于串,其作用是避免与变量名或常量混淆。ai(1≤i≤n)称为串的元素，它可以是任意字母、数字或其他字符，是构成串的基本单位，i是它在整个串中的序号。n是串中字符的个数,称为串的长度，表示串中所包含的字符个数。例如串S1="abcd"，串的每一个元素为一个字母，其长度为4。而S2="12345"，串的每一个元素为一个数字，其长
顺序串的复制，判断相等，连接，子串，查找子串在母串位置，插入，删除（顺序串篇）
qq_46104786的博客
11-07 6889
前言： 前面我们把栈和队列已经学的差不多了，今天来复习一下，数据结构的串，串的存储结构，在Java里面是有String类型的，但是C语言里面是没有的，需要自己封装一下，再进行操作。串是由零个或多个字符组成的有限序列，串长度为零我们称为空串，它不含任何字符。在学习串我们只要学习，串的算法，例如复制，连接，判断相等，求子串之类的算法。 每日一遍，心情愉悦 （你们应该没有这样的损友吧，????????????） 1.顺序串 顺序串的存储结构的和线性表一样，也是主要分为顺序存储结构和链式存储结构两类，前者简称顺序
【数据结构】数组和字符串（十二）：顺序存储字符串的基本操作（串长统计、查找、复制、插入、删除、串拼接）
最新发布
天地玄黄 魑魅魍魉 风花雪月 商角徵羽 暂时停更 十月重见
10-31 976
本文详细介绍了顺序存储字符串的基本操作：串长统计、查找、复制、插入、删除、串拼接等（包含错误检查和报错机制）
数据结构基础知识（一）
农夫果园好好喝的博客
01-12 1489
线性表是由n个相同类型的数据元素组成的有限序列，它是最基本最常用的一种线性结构。顾名思义，线性表就像是一条线，不会分叉。线性表有 唯一的开始和结束，除了第一个元素外，每个元素都有唯一的直接前驱：除了最后一个元素外，每个元素都有唯一的直接后继。顺序表的两种存储结构为顺序表和链表线性表是具有n个数据元素的优先序列。栈的类型定义这种后进先出（LastFirstOut，LIFO）的线性序列，称为“栈”。栈也是一种线性表，只不过它是操作受限的线性表，只能在一端进出操作。
数据结构——顺序串 C语言
03-16
若主串S中存在和串T值相同的子串，返回它在主串S中所有出现的位置。
数据结构 顺序串
03-02
数据结构 顺序串 包含无回溯类型匹配（BMP）算法
c语言数据结构顺序表合并
12-01
1.建立两个顺序表（通过随机函数生成）； 2.排序（升序），输出合并前的结果； 3.对这两个顺序表进行合并（保持升序）； 4.输出合并结果
合工大数据结构顺序表实验
04-14
18级合工大数据结构实验
数据结构顺序表，c语言简单实现
01-12
数据结构顺序表，c语言简单实现
掌握串的基本处理操作和几种不同的存储结构（定长顺序存储表示、堆分配存储表示和块链存储表示）。
09-10
二、 实验要求 1、 实现串赋值、串比较、求串长、串联接以及求子串这5种基本操作。 2、 能利用上述实现的基本操作完成置换Replace (&S, T, V)以及从串中删除一段子串StrDelete(&S,pos,len)的操作。 3、 以上要求实现的操作不能直接使用C语言提供的函数(gets()，puts()除外)完成。 4、 所写源代码编程风格良好，有详细注释。 5、 程序运行界面良好，使用菜单实现每个基本操作。
数据结构之顺序串的基本操作(C语言)
永不秃头的George的博客
04-16 2418
----------------------✨🎉🎈==！！！热烈欢迎各位大佬！！！==🎈🎉✨---------------------- 🍹作者： BooleanChar12 ✨博客主页： BooleanChar12的博客 💘很喜欢的一句话： Because we all stand on the shoulders of giants. 🥂如有bug和疑惑欢迎大家与我🤺 😍觉得博主文章写的不错的话，希望大家三连（🎉关注，🎉点赞，🎉评论），多多支持一下！！ -----------------------
数据结构之串的定长顺序存储
偶然i的博客
03-13 3015
技术交流qq：1032492413 技术交流VX:Chamfion
数据结构（C语言）——第四章、串（1）串的顺序存储
m0_43416592的博客
09-04 703
目录静态数组动态数组 说明：串的顺序存储操作，分为静态数组和动态数组两类。两者的操作差别不大，注意看动态数组前面的补充内容。 静态数组 // // @Author: Brisa // @Date: 2021/9/4 // @Description: 串的顺序存储 // 静态数组实现（定长顺序存储） // 舍弃数组0号位，从1开始存取等操作 // #include<stdio.h> #include<string.h> #de
串的动态顺序存储代码
weixin_30535565的博客
09-03 128
由于静态顺序存储使用C语言实现有些麻烦，其次容易产生溢出，因此就不对串的静态顺序存储实现了，而是采用 动态顺序存储，使得存储串的长度可以动态分配存储空间。下面是它的实现代码 #include <stdio.h> #include <stdlib.h> #define OK 1 typedef int Status; typedef struct { ...
【数据结构】-串的顺序存储(静态分配）
RunningSnail的博客
08-02 2889
串的定长顺序存储-静态分配1.头文件及类型定义2.串类型定义3.函数声明4.基本操作4.1 初始化串4.2 求串长4.3 清空4.4 判空4.5 赋值操作★4.6 复制操作★4.7 联接操作★4.8 求子串操作★★4.9 比较操作★★4.10 定位操作★★★4.11 遍历4.9 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #include<stdlib.h> #define MAXLEN 10 //预定义最大串长为255 2.串类型定义 ty
串的顺序存储
minyuanxiani的专栏
09-05 495
#include using namespace std; #define MaxStrSize 256 typedef struct mystring { char str[MaxStrSize]; int len; }MyString; /* 掩饰符号类型。例如当需要定义多个包含80个元素的数组a，b，c时，可以这样定义：
《数据结构》（C语言版）——串的定长顺序存储表示
prlhnxx的博客
04-05 2332
/* 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...
数据结构（十五）串的顺序存储结构（顺序串）
weixin_30887919的博客
06-19 889
　　一、串的定义：串（String）是由零个或多个字符组成的有限序列，又名叫字符串。 　　二、串中的字符数目n称为串的长度，零个字符的串称为空串（null string），它的长度为零。子串在主串中的位置就是子串的第一个字符在主串中的序号。 　　三、串的大小：首先比较每个字符对应的ASCII码，然后比较长度n。 　　四、串中关注更多的是查找子串位置、得到指定位置子串、替换子串等操作...
数据结构顺序串的基本操作C语言
10-28
顺序串是一种线性表的存储结构，它是由一组连续的存储单元来存储的。在C语言中，我们可以使用结构体来定义顺序串，如下所示： ``` #define MAXSIZE 256 typedef struct String { char ch[MAXSIZE]; int length; }...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值