串(string)的堆方式实现详解----线性结构

最新推荐文章于 2024-01-09 17:47:00 发布
最新推荐文章于 2024-01-09 17:47:00 发布
阅读量779 收藏 5
点赞数 1
分类专栏： 计算机综合基础(408) # 数据结构 文章标签： C++ 字符串 堆串 动态内存 字符串操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43479947/article/details/113732358
版权

前面已经完成了线性表、栈、队列等线性表的学习与实现，今天终于完成了线性结构中另一重要的数据结构----串(string)，来和大家分享一下，共同进步。

串，又称字符串。

其实串就是由一个或多个字符组成的字符序列，使用串可以方便地存储我们想要存储的一切信息。

假如我们现在需要存储某个同学的具体姓名、某个名人名言、某个段落、某篇文章，这些信息中既包含有数字信息、英文信息、中文信息、标点符号、特殊符号等，我们此时就可以用 串(string) 来进行存储了。

串拥有很多操作方法，如初始化字符串、拷贝字符串、检索字符串、截取字符串、连接字符串、插入字符串、删除字符串、替换字符串、比较字符串等，使用这些方法可以很方便地对字符串进行各种操作，实现用户的需要。

串可以分为顺序串和堆串。

顺序串采用字符数组进行实现，由于采用字符数组需要预先开辟一个固定的存储空间，而且不易拓展，所以这篇文章暂时不为大家推荐顺序串，顺序串具体的代码我一会分享给大家。

堆串采用堆的方法动态地为串的内容开辟内存空间，能够有效的节约内存资源，并有益于串的扩展操作和兼容操作，便于用户操作。

下面是串的具体实现代码，如果有小伙伴有不理解的地方或者疑虑，欢迎留言评论~

文章目录

串的定义

#include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

#define STRING_INIT_SIZE 100

//定义字符串 string 类型 
typedef struct StringNode{
	char *content;			//字符串内容 content 
	int length;				//字符串长度 length 
}*String;
所有方法的声明

int initString(String &string);						//初始化线性化结构 串(string) 
int destroyString(String &string);					//销毁字符串string  
int isEmptyString(String &string);					//判断是否为空串 
int strLength(String &string);						//返回字符串的长度 
void printString(String &string);					//打印字符串string
int clearString(String &string);					//清空字符串
int assignString(String &string, char chars[]);					//生成一个值为常量为chars的字符串string 
int copyString(String &string, String s);						//拷贝字符串，将字符串s拷贝赋值给string 
int compareString(String &string, String s);					//对比两个字符串，若string>s，返回>0，相等返回0，否则返回<0
int concatString(String &string, String s1, String s2);			//将s1和s2连接的新串赋值给string 
int subString(String &string, String &s, int pos, int len);		//截取字符串，以s串返回string字符串第pos开始len个长度的串 
int indexString(String &string, String s, int pos);				//检索字符串，返回string串第pos位置后第一次和s串相同子串的开始位置，否则返回0 
int replaceString(String &string, String s1, String s2);		//替换字符串，以串s2替换掉string串中所有的串s1 
int insertString(String &string, String s, int pos);			//插入字符串，将子串s插入到string字符串的第pos个位置 
int deleteString(String &string, int pos, int len);				//删除字符串，删除string字符串中第pos个位置开始，长度为n的字串
初始化字符串数据类型
//使用字符数组对串进行初始化 
int assignString(String &string, char chars[])
{
	int i, j;
	char *p = chars;					//定义一个字符指针指向字符数组 
	while(*p != '\0' && *p != '\n')			//循环统计字符数组长度 
	{
		p++;
		i++;							//计数器累加 
	}
	
	string->content = (char *)malloc(i*sizeof(char));	//动态地为串的内容开辟相应地内存空间存储串信息 
	string->length = i; 				//设置串的长度 
	
	for(j = 0; j < i; j++)
	{
		string->content[j] = chars[j];		//将字符数组内容复制给串的内容	
	}
	string->content[j] = '\0';			//字符串内容的最后一位设置为字符结束符 
	return OK;						//返回结果 
}
拷贝字符串

//复制字符串，将字符串s的内容复制给string 
int copyString(String &string, String s)
{
	int length = s->length;					//记录字符串s的长度 
	if(length == 0)							//若字符串的长度为0，则直接清空string串，返回 
	{
		clearString(string);
		return OK;
	}
	else									//否则 
	{
		//根据新的内容使用realloc()函数重新为串string开辟内容空间 
		string->content = (char *)realloc(string->content, length*sizeof(char));
		char *p = s->content, *q = string->content;		//定义p指针指向s内容，q指针指向string内容 
		while(*p != '\0' && *p != '\n')			//使用p指针重复读取s之中的内容，直至s串结束 
		{
			*q = *p;				//将p指针中的内容赋值给q指针指向的内容，进行复制 
			p++;
			q++;					//p、q指针累加，指向串中的下一内容 
		}
		*q = '\0';					//复制完毕，q指针指向的string串以'\0'结束 
		string->length = s->length;			//更新串string的长度 
		return OK;			//返回结果 
	}
	
}
比较字符串

//对两个字符串string和s进行比较，
//若string > s，返回 > 0；
//若string < s，返回 < 0；
//否则返回0 
int compareString(String &string, String s)
{
	//循环比较string串和s串，当string和s的第一个字符相等时，比较第2个，再相等比较第3个...，直至string串或s串结束 
	for(int i = 0; i < string->length && i < s->length; i++)
	{
		if(string->content[i] != s->content[i])			//若两个串的某个位置的字符串不等 
			return string->content[i] - s->content[i];		//返回它们的差值，即为结果(ASCLL码) 
	}
	return string->length - string->length;			//若持续相等，返回它们的长度的差值 
}
连接字符串

//将字符串s1和字符串s2连接成为新的字符串string 
int concatString(String &string, String s1, String s2)
{
	int length = s1->length + s2->length, i;	//记录s1和s2字符串长度之和 
	string->content = (char *)realloc(string->content, length*(sizeof(char)));		//重新为string串内容开辟此长度的空间 
	//通过循环的方式连接两个字符串 
	for(i = 0; i < length; i++)
	{
		if(i < s1->length)			//若 i < s1的长度，则先添加s1字符串内容 
			string->content[i] = s1->content[i];
		else						//之后再添加s2字符串的内容 
			string->content[i] = s2->content[i-(s1->length)];
	}
	string->content[i] = '\0';		//连接形成的新的字符串string以'\0'结束 
	string->length = length;		//更新字符串string的长度 
	
	return OK;		//返回结果 
}
截取字符串

//截取字符串，把string字符串的第pos个位置开始，长度为len的子字符串截取下来，赋值给s返回 
int subString(String &string, String &s, int pos, int len)
{
	if(pos < 1 || pos > string->length || len < 0 || len > string->length+1)
		return ERROR;			//若截取参数有误，直接返回错误信息 
	
	int i = 0;			//定义计数器 
	s->content = (char *)malloc(len*sizeof(char));		//动态为s字符串开辟长度为len的字符串内容 
	s->length = len;					//并设置字符串的长度 
	
	//从字符串的第pos个位置开始，循环进行截取内容 
	for(i = pos-1; i < pos-1+len; i++)
	{
		s->content[i-(pos-1)] = string->content[i];		//截取内容赋值给s字符串 
	}
	
	s->content[i-(pos-1)] = '\0';		//为s字符串的最后字符'\0'作为字符串结束标志 
	return OK;		//返回结果 
}
插入字符串

//在字符串string的第pos个位置插入新的字符串s 
int insertString(String &string, String s, int pos)
{
	if(s->length == 0 || pos < 1 || pos > string->length+1)
		return ERROR;		//若插入参数有误，直接返回错误信息 
	
	int length = string->length + s->length;		//对插入的长度进行增加保存 
	
	int i = 0;
	String new_string; 				//定义新的new_string字符串准备接收 
	initString(new_string);			//初始化new_string字符串 
	new_string->content = (char *)malloc(length*sizeof(char));		//动态为该字符串开辟长度为length的空间 

	//循环通过3段连接的方式进行字符串的添加，暂添加至new_string 
	for(i = 0; i < length; i++)
	{
		if(i < pos-1)
			new_string->content[i] = string->content[i];	//添加pos之前string字符串的内容 
		else if(i >= pos-1 && i < pos - 1 + s->length)
			new_string->content[i] = s->content[i-(pos-1)];		//添加s字符串的内容 
		else
			new_string->content[i] = string->content[i-s->length];		//添加pos位置之后string字符串的内容 
	}
	new_string->content[i] = '\0';		//字符串new_string内容以'\0'结束标志 
	new_string->length = length;		//设置字符串长度 
	
	copyString(string, new_string); 	//进行字符串复制，即此时string便是已成功插入的字符串 
	return OK;		//返回结果 
}
删除字符串

//删除字符串string从第pos个位置开始，长度为len的子串 
int deleteString(String &string, int pos, int len)
{
	if(pos < 1 || pos > string->length || len < 1 || pos - 1 + len > string->length)
		return ERROR;		//若删除参数有误，直接返回错误信息 
		
	int i,j;
	String new_string;		//同插入字符串操作，定义新的字符串new_string 
	initString(new_string);			//初始化字符串 
	new_string->content = (char *)malloc((string->length-len)*(sizeof(char)));		//为新的字符串内容动态开辟空间 
	
	//循环通过2段字符串的连接进行子串的删除 
	for(i = 0, j = 0; i < string->length; i++)
	{
		if(i < pos-1)
			new_string->content[j++] = string->content[i];		//添加pos位置之前的string串的内容 
		if(i >= pos-1+len)
			new_string->content[j++] = string->content[i];		//添加pos-1+len位置之后string串的内容，便实现删除 
	}
	new_string->content[j] = '\0';				//字符串new_string内容以'\0'结束标志 
	new_string->length = string->length-len;	//设置字符串的长度 
	
	copyString(string, new_string);			//进行字符串复制，即此时string便是已成功删除子串的字符串 	
	return OK;			//返回结果 
}
替换字符串


//字符串替换操作，将string串中所有s1子串替换为s2子串 
int replaceString(String &string, String s1, String s2)
{
	if(string->length == 0)			//string为空串，直接返回 
		return ERROR;
	if(indexString(s2, s1, 1) != 0)		//s2中包含s1子串，会造成递归无限替换，直接返回 
		return ERROR;
	
	for(int i = 0; i < string->length; i++)			//循环检索所有的情况 
	{
		int j = indexString(string, s1, i+1);			//从第i+1个位置后检索string串是否包含s1串，若包含，返回子串开始位置 
		if(j > 0)			//若包含 
		{
			deleteString(string, j, s1->length);		//删除string中的从j位置开始的子串 s1 
			insertString(string, s2, j);				//添加子串s2 到字符串string的第j个位置，替换成功 
		}
	}
	
	return OK;			//返回结果 
}
检索字符串

//从第pos个位置开始，检索string中是否包含子串s，若包含返回第一次发现子串的起始位置，否则返回0 
int indexString(String &string, String s, int pos)
{
	if(pos > string->length)
		return ERROR;			//若pos位置有误，直接返回 

	String new_string; 
	initString(new_string);			//定义并初始化新的字符串new_string 
	for(int i = pos-1; i < string->length; i++)		//从第pos个位置循环检索每一个子串 
	{
		subString(string, new_string, i+1, s->length);		//截取string串中的每个子串 
		if(compareString(new_string, s) == 0)		//若该子串和子串s相等，说明检索成功 
			return i+1;				//返回该子串的起始位置 
	}
	
	return FALSE;			//否则，返回false，即0 
}
字符串判空、清空、销毁、打印字符串


//判断字符串string是否为空串 
int isEmptyString(String &string)
{
	if(string->length == 0)
		return TRUE;			//空串返回1 
	else
		return FALSE;			//否则返回0 
}


//返回字符串string的长度，冗余操作 
int strLength(String &string)
{
	return string->length;
}


//清空字符串string
int clearString(String &string)
{
	free(string->content);		//释放string字符串内容空间 
	string->content = NULL;		//设置string内容空间为NULL 
	string->length = 0;			//设置string内容长度为0 
	return OK;		//返回结果 
}


//销毁字符串string
int destroyString(String &string)
{
	clearString(string);		//清空字符串string
	
	free(string);			//释放字符串string空间 
	string = NULL;			//字符串string为NULL 
	
	return OK;			//返回结果 
}


//打印字符串string
void printString(String &string)
{
	printf("字符串的内容为:\n");
	printf("%s\n", string->content);
	printf("长度---->%d.\n", string->length);
	return;
}

好啦，明天有空再把串的顺序实现代码分享给大家，加油~

Gaolw1102
关注
专栏目录
数据结构之串结构的实现--堆分配结构(C语言)
RSDTE
09-18 657
学习参考: 严蔚敏: 《数据结构-C语言版》 基本操作  赋值操作 字符串连接 取长度 字符串比较 求子串 输出字符串 清空操作 代码实现 结构定义: typedef struct { char* ch; int length; }*pStr, DynString;  赋值操作 int strAssign(pStr str, char* ch) { int...
Scikit-Learn线性回归(一)
Java/Python大数据成长之路
12-25 1747
线性回归（Linear Regression）是很基础的机器学习算法。回归（Regression）是一种应用广泛的预测建模技术，这种技术的核心在于预测的结果是连续型变量回归是监督学习中的一个重要问题，用于预测输入变量（自变量）和输出变量（因变量）之间的关系，特别是当输入变量的值发生变化时，输出变量的值随之发生的变化，回归模型正是表示从输入变量到输出变量之间映射的函数其中，自变量表示主动操作的变量，可以看做因变量的原因。因变量因为自变量的变化而变化，可以看做自变量的结果。
串的堆存储结构
qq_40729286的博客
09-20 810
#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 typedef int Status; #define MAXSTRLEN 40 //...
串的堆式存储结构
热门推荐
顾修忠的博客
10-27 1万+
串的堆式存储结构 在C和C++语言中 ，提供一个称之为“堆”的共享空间，可以在程序运行过程中，系统利用函数malloc( )和free( )动态地申请或释放一块连续空间。 由于在C和C++语言中可以用指针对数组进行访问和操作，在串的存储和操作上也可以充分利用上述特性。 串的堆式存储结构类似于线性表的顺序存储结构，以一组地址连续的存储单元存放串值字符序列，其存储空间是在程序执行过程中动态分配的
串的堆分配实现
非典型程序员
09-12 739
注意事项： 在串的顺序存取中，一旦操作的串序列长度超过上界时，会采用截尾法处理，克服这个弊端可以使用动态分配串值得存储空间。 堆分配——也是以一组地址连续的存储单元存放串值字符序列，但他们的存储空间是在程序运行过程中动态分配而得。 一般对串操作时，多使用堆分配存储方式。 #include<stdio.h> #include<string.h> #include<m...
串的存储结构(堆串)
冲出仁川，走出马德里，故事还会再继续
06-12 4604
串的存储结构(堆串) 一、堆串简介         串的堆存储结构，与定长顺序串的存储结构类似，都是用一维数组地址连续的存储单元存储串的字符序列，不同的是堆串的存储空间是在程序执行过程中动态分配的。         在系统中存在一个称为“堆”的自由存储区，每当建立一个新串时，可以通过动态分配函数从这个空间中分配一块实际串所需的存储空间，来存储新的串值
C与C++数据结构与算法基础详解---（串的模式匹配）KMP算法
weixin_45417450的博客
01-12 676
** 数据结构—（串**（String）**） ** 串的定义：串是由任意多个字符组成的有限数列，可以为数字、字母、其他。 通常一个串含有（主串与子串），而子串在主串中的位置以子串在主串中的第一个字符位置来表示。而当串中元素为空格时为空串，串操作一般用于文本编辑。它与一般数据结构的区别在于其数据类型为 “字符集”。 【串的分类】：按存储方式：顺序存储（定长顺序）、链式存储与堆分配存储。 【顺序...
Scikit-Learn线性回归(六)
最新发布
Java/Python大数据成长之路
01-09 652
由于惩罚项是关于回归系数ω的绝对值之和，因此惩罚项在零点处是不可导的，导致其代价函数不是处处可导的，所以就没办法通过直接求导的方式来直接得到解析解ω，类似于应用在岭回归上的最小二乘法在此失效。但不同的是，Lasso回归针对不同的自变量，会使其收敛的速度不一样。坐标轴下降法与梯度下降法类似，都属于迭代算法，不同的是，坐标轴下降法是是沿着坐标轴（维度）下降，而梯度下降法是沿着梯度的负方向下降。相比于岭回归模型的抛物面（圆面），L1正则化项的正四边形顶点更容易与损失函数的同心圆相交，更能起到特征选择的效果。
Android-《HenCoderAndroid开发进阶UI1-2Paint详解》的练习项目
08-13
《HenCoder Android开发进阶UI1-2Paint详解》的练习项目专注于深入理解并熟练运用Android中的Paint对象，以提升开发者在图形绘制方面的技能。在这个项目中，开发者将有机会实践各种Paint属性的设置和应用，从而掌握...
数据结构动态存储分配-堆分配详解
"堆分配存储表示是数据结构中一种动态管理内存的方式，特别是在程序执行过程中根据需要分配和释放存储空间。这种表示方法常用于顺序表的实现，即字符序列的存储。在C语言中，可以使用`malloc`和`free`函数来动态地...
《数据结构》-堆串的表示和实现
tyustli
02-23 458
#include <string.h> #include <malloc.h> #include <stdio.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 typedef int Status; // Status是函数的类型,其...
字符串 堆实现
Someone16111的博客
01-12 479
#ifndef _STRING_H_ #define _STRING_H_ #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -1 typedef int Status; typedef struct {  char *ch;  int length; }HString;
【学数据结构】-----串（顺序串、堆串、块链串）（7000字总结+代码+图）
登登的博客 是温馨的小屋。
06-10 3559
计算机处理的对象分为数值处理和非数值处理，字符串是最基本的非数值数据。 字符串处理在语言编译、信息检索、文字编辑等领域有着广泛的应用。 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。...
java string 堆_java堆与栈 java String分配内存空间（详解）转
weixin_32589453的博客
02-24 172
运行时数据区域 Java虚拟机在执行Java的过程中会把管理的内存划分为若干个不同的数据区域。这些区域有各自的用途，以及创建和销毁的时间，有的区域随着虚拟机进程的启动而存在，而有的区域则依赖线程的启动和结束而创建和销毁。 Java虚拟机栈内存堆内存基础类型，对象引用(堆内存地址)由new创建的对象和数组，存取速度快相对于栈内存较慢数据大小声明周期必须确定分配的内存由j...
java string 堆_java字符串池（string pool）和字符串堆（heap）内存分配
weixin_33997127的博客
02-24 238
java运行环境有一个字符串池(string pool),由String类维护。执行语句 String str = "abc" 时，首先查看字符串池中是否存在字符串"abc" ，如果存在则直接将"abc"地址赋给str ，如果不存在则先在字符串池中新建一个字符串"abc"，然后再将其赋给str。执行语句 String str = new String("abc") 时，不管字符串池中是否存在"ab...
堆串的操作（C实现）
m0_61395860的博客
02-12 1415
一、堆串概念。 与定长顺序穿的存储结构类似，都是用一组地址连续的存储单元存储串的字符序列，不同的是堆串的存储空间是动态分配的，只要存储空间分配成功，就不会担心串在插入或者连接时候出现截断的情况。 malloc(),free(),realloc() 这三个函数用来对动态存储进行操作。 二、基本操作。 #include<stdio.h> #include<stdlib.h> #include<string.h> #define false 0 #define t..
第四章（2）串的堆分配的所有操作
qq_40191710的博客
02-01 1350
第四章（2）串的堆分配的所有操作 利用堆来存储顺序表： #include #include #include //--------ADT String 的表示与实现------- //1、初始化字符串 //Status InitString(HString *T) //2、生成一个其值等于串常量 chars 的串 T //Status StrAssign(HStr
【数据结构】堆串的连接，替换，插入操作
Chen_yuazzy的博客
04-14 3455
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<malloc.h> typedef char Elemtype; typedef int Datatype; typedef struct { Elemtype *ch; //指针域，指向存放串值的存储空间基址 ...
【数据结构】堆存储结构的串原子操作实现
haohulala的博客
07-09 476
使用堆存储结构的串的长度任意，比使用顺序存储结构的串更加灵活易用 #include <stdio.h> #include <stdlib.h> //串的堆分配结构 typedef struct { char *ch; int length; } HString; typedef int Status; #define OK 1 #define ER...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Gaolw1102

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值