数据结构笔记（十三）-- 串的堆分配存储表示

最新推荐文章于 2023-09-22 13:57:50 发布
最新推荐文章于 2023-09-22 13:57:50 发布
阅读量4.6k 收藏 106
点赞数 20
文章标签： 字符串 数据结构 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43609475/article/details/106711738
版权

串的堆分配存储表示

一、堆分配存储概述

堆分配内存仍是一组地址连续的存储单元来存放串值字符序列，但是存储空间实在程序执行过程中动态分配而得。在C语言中，存在一个称为“堆”的自由存储区，并由C语言的动态分配函数malloc()和free()来管理。利用函数malloc()为每个新产生的串分配一块实际串长所需的存储空间，若分配成功，则返回一个指向起始地址的指针，作为串的基址，同时为了方便以后的处理，约定串长也作为存储结构的一部分。

二、串的堆分配存储结构

在这里插入图片描述
在这里插入图片描述

三、串的操作

//1、初始化(产生空串)字符串S
void InitString(pHString S);
//2、将S清为空串
void ClearString(pHString S);
//3、生成一个其值等于串常量chars的串S
void StrAssign(pHString S, char *chars);
//4、显示字符串
void StrShow(pHString S);
//5、复制串S到T
void StrCopy(pHString T, pHString S);
//6、判断串是否为空，若为空返回True，否则返回false
bool StrEmpty(pHString S);
//7、比较两个串的最前面字符的ASCII码的大小，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0 
int StrCompare(pHString S, pHString T);
//8、返回S的元素个数，称为串的长度
int StrLength(pHString &S);
//9、用T返回由S1和S2联接而成的新串
void StrConcat(pHString S1, pHString S2, pHString T);
//10、用Sub返回串S的第pos个字符起长度为len的子串。
bool StrSub(pHString Sub, pHString S, int pos, int len);
//11、找出子串T值主串S中的位置（与子串首字符相等的位置）
int Index1(pHString S, pHString T);
//12、 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0,其中，T非空，1≤pos≤StrLength(S)。
int Index2(pHString S, pHString T, int pos);
//13、从串S中删除第pos个字符起长度为len的子串,从新申请空间
bool StrDelete1(pHString S, int pos, int len);
//14、从串S中删除第pos个字符起长度为len的子串，调整内存空间
bool StrDelete2(pHString S, int pos, int len);

typedef struct HString
{
	char * ch; // 若是非空串，则按串长分配存储区，否则ch为NULL
	int length; // 串长度
}HString,*pHString;

1、初始化(产生空串)字符串S

在这里插入图片描述

void InitString(pHString S)
{ 
	S->ch = NULL;
	S->length = 0;	
}

2、将S清为空串

在这里插入图片描述

void ClearString(pHString S)
{ 
	free(S->ch);
	S->ch = NULL;
	S->length = 0;
}

3、生成一个其值等于串常量chars的串S

在这里插入图片描述

void StrAssign(pHString S, char *chars)
{
	int i, j;
	if (S->ch)//若S的指针不为空则释放S指针域所指向的空间
		free(S->ch); // 释放S原有空间
	i = strlen(chars); // 求chars的长度i
	if (!i)//若果字符串为空则清空S（相当于复制了一个空字符串）
	{ // chars的长度为0
		S->ch = NULL;
		S->length = 0;
	}
	else
	{ // chars的长度不为0
		S->ch = (char*)malloc(i * sizeof(char)); // 分配大小跟chars大小相同的串空间
		if (!S->ch) // 分配串空间失败
			exit(-1);
		for (j = 0; j < i; j++) // 复制串
			S->ch[j] = chars[j];
		S->length = i;
	}
}

4、显示字符串

void StrShow(pHString S)
{ 
	int i;
	for (i = 0; i < S->length; i++)
		printf("%c", S->ch[i]);
	printf("\n");
}

5、复制串S到T

在这里插入图片描述

void StrCopy(pHString T,pHString S )
{
	if (T->ch)
		free(T->ch); // 释放T原有空间
	T->ch = (char *)malloc(S->length*(sizeof(char)));//申请内存
	if (T->ch == NULL)
	{
		printf("内存分配失败！");
		exit(-1);
	}
	for (int i = 0; i < S->length; i++)//逐一复制
	{
		T->ch[i] = S->ch[i];
	}
	T->length = S->length;//复制串长
	
}

6、判断串是否为空，若为空返回True，否则返回false

bool StrEmpty(pHString S)
{
	if (S->length==0&&S->ch==NULL)//空串标志
	{
		return true;
	}
	else
	{
		return false;
	}
}

7、比较两个串的最前面字符的ASCII码的大小，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0

在这里插入图片描述

8、返回S的元素个数，称为串的长度

int StrLength(pHString &S)
{ 
	return S->length;
}

9、用T返回由S1和S2联接而成的新串

在这里插入图片描述

void StrConcat(pHString S1, pHString S2, pHString T)
{

	if (T->ch)
		free(T->ch); // 释放T原有空间
	T->ch = (char *)malloc((S1->length + S2->length)*(sizeof(char)));//申请内存
	if (T->ch == NULL)
	{
		printf("内存分配失败！");
		exit(-1);
	}
	for (int i = 0; i < S1->length; i++)//逐一复制S1
	{
		T->ch[i] = S1->ch[i];
	}
	for (int i = 0; i < S2->length; i++)//接着逐一复制S2
	{
		T->ch[S1->length +i] = S2->ch[i];
	}
	T->length = (S1->length + S2->length);//复制总串长
}

10、用Sub返回串S的第pos个字符起(包括pos位置处的字符)长度为len的子串。

在这里插入图片描述

bool StrSub(pHString Sub,pHString S,int pos,int len)
{
	if (StrEmpty(S))
	{
		return	false;
	}
	if (pos<1||pos>S->length||len<0||len>S->length-pos+1)//排除不符合条件的pos和len
	{
		return	false;
	}
	if (Sub->ch)
		free(Sub->ch); // 释放旧空间
	if (!len) // 空子串
	{
		Sub->ch = NULL;
		Sub->length = 0;
	}
	else
	{
		Sub->ch = (char*)malloc(len * sizeof(char));//申请len个空间
		if (!Sub->ch)
			exit(-1);
	}
	for (int i = pos; i < pos+len; i++)//逐个复制
	{
		Sub->ch[i - pos] = S->ch[i-1];
	}
	Sub->length = len;//保存长度
	return true;
}

11、找出子串T值在主串S中的位置（与子串首字符相等的位置）

在这里插入图片描述

int Index1(pHString S, pHString T)
{
	int i,j;
	for (i = 0; i < S->length; i++)//循环主串
	{
		if (S->ch[i] == T->ch[0])//如果在主串中找到一个与子串的第一个字符相等的字符时
		{
			int cont = 1;//计数变量
			for (j = 0; j < T->length; j++)//遍历子串
			{
				if (T->ch[j + 1] != S->ch[i + j+1])//在遍历T[0]时如果有不一致时退出遍历
				{
					break;
				}
				else//否则计数
				{
					cont++;
					if (cont == T->length)//当有T[0]个字符相同时则找到子串位置
						return i+1;
				}
			}
		}
		continue;
	}
	return 0;//不存在时
}

12、返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0,其中，T非空，1≤pos≤StrLength(S)。在这里插入图片描述

int Index2(pHString S, pHString T, int pos)
{
	int i, j;
	if (1 <= pos && pos <= S->length)
	{
		i = pos;//从主串的第pos个字符开始和子串的第一个字符比较
		j = 0;
		while (i <= S->length && j < T->length)
		{
			if (S->ch[i] == T->ch[j]) // 若找到主串字符与子串首字符相等时继续比较后继字符
			{
				++i;
				++j;
			}
			else // 指针后退，主串字符下标后移一位，重新开始匹配
			{
				i = i + 1;
				j = 0;
			}
		}
		if (j == T->length)//条件成立，子串在主串中
			return i - T->length+1;//因为i是下标，下标编程序号需要+1
		else
			return 0;
	}
	else
		return 0;
}

13、从串S中删除第pos个字符起长度为len的子串,从新申请空间

在这里插入图片描述

bool StrDelete1(pHString S, int pos, int len)
{
	if (StrEmpty(S))//S为空时
	{
		return	false;
	}
	if (pos<1||pos>S->length||len<0||len>S->length-pos+1)//pos和len不满足条件时
	{
		return false;
	}
	char *pNew = (char*)malloc((S->length - len) * sizeof(char));//从新申请空间
	if (pNew==NULL)//申请失败
	{
		return false;
	}
	for (int i = 0; i < pos-1; i++)//复制pos前的字符
	{
		pNew[i] = S->ch[i];
	}
	for (int i = pos+len-1; i < S->length; i++)//复制pos+len-1后的字符
	{
		pNew[i-len] = S->ch[i];
	}
	free(S->ch);//释放原内存
	S->ch = pNew;
	S->length = S->length - len;//更新长度
	return true;
}

14、从串S中删除第pos个字符起长度为len的子串，调整内存空间

在这里插入图片描述

bool StrDelete2(pHString S, int pos, int len)
{
	int i;
	if (StrEmpty(S))//S为空时
	{
		return	false;
	}
	if (S->length < pos + len - 1)//pos和len不满足条件时
		return false;
	for (i = pos - 1; i <= S->length - len; i++)//从pos + len - 1起，之后的元素向前移动
		S->ch[i] = S->ch[i + len];
	S->length -= len;
	S->ch = (char*)realloc(S->ch, S->length * sizeof(char));//调整S->ch的空间
	return true;
}

最后给出完整代码

// 串的堆分配存储.cpp 
#include<string.h>
#include<malloc.h> // malloc()等
#include<stdio.h> // EOF(=^Z或F6),NULL
#include<stdlib.h> // atoi()

typedef struct HString
{
	char * ch; // 若是非空串，则按串长分配存储区，否则ch为NULL
	int length; // 串长度
}HString,*pHString;

//1、初始化(产生空串)字符串S
void InitString(pHString S);
//2、将S清为空串
void ClearString(pHString S);
//3、生成一个其值等于串常量chars的串S
void StrAssign(pHString S, char *chars);
//4、显示字符串
void StrShow(pHString S);
//5、复制串S到T
void StrCopy(pHString T, pHString S);
//6、判断串是否为空，若为空返回True，否则返回false
bool StrEmpty(pHString S);
//7、比较两个串的最前面字符的ASCII码的大小，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0 
int StrCompare(pHString S, pHString T);
//8、返回S的元素个数，称为串的长度
int StrLength(pHString &S);
//9、用T返回由S1和S2联接而成的新串
void StrConcat(pHString S1, pHString S2, pHString T);
//10、用Sub返回串S的第pos个字符起长度为len的子串。
bool StrSub(pHString Sub, pHString S, int pos, int len);
//11、找出子串T值主串S中的位置（与子串首字符相等的位置）
int Index1(pHString S, pHString T);
//12、 返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0,其中，T非空，1≤pos≤StrLength(S)。
int Index2(pHString S, pHString T, int pos);
//13、从串S中删除第pos个字符起长度为len的子串,从新申请空间
bool StrDelete1(pHString S, int pos, int len);
//14、从串S中删除第pos个字符起长度为len的子串，调整内存空间
bool StrDelete2(pHString S, int pos, int len);

int main()
{
	HString S, T, S1,Sub;
	InitString(&S);	
	InitString(&S1);	
	InitString(&T);
	InitString(&Sub);
	char chars[] = "god bye!";
	StrAssign(&S, chars);
	StrShow(&S);

	StrCopy(&T,&S);
	StrShow(&T);
	if (StrEmpty(&S))
	{
		printf("串S为空\n");
	}
	else
	{
		printf("串S不为空\n");
	}
	char char1[] = "god hello!";
	StrAssign(&T, char1);
	StrShow(&T);
	printf("比较S和T的结果%d\n", StrCompare(&S, &T));
	StrAssign(&S1, char1);
	printf("拼接字符串");
	StrShow(&S);
	StrShow(&S1);
	StrConcat(&S,&S1,&T);
	StrShow(&T);

	int pos = 3, len = 3;
	if (StrSub(&Sub, &S, pos, len))
	{
		StrShow(&Sub);
	}
	HString SS, TT;
	InitString(&SS);
	InitString(&TT);
	char char2[] = "abcdefghijklmn";
	char char3[] = "bcd";
	StrAssign(&SS, char2);
	StrShow(&SS);
	StrAssign(&TT, char3);
	printf("子串T在主串S中的位置为 %d\n", Index1(&SS,&TT));
	printf("子串T在主串S中的位置为 %d\n", Index2(&SS,&TT,5));
	StrShow(&SS);
	StrDelete1(&SS, pos, 3);
	StrShow(&SS);
	StrDelete2(&SS, pos, 3);
	StrShow(&SS);
	


	return 0;
}


//1、初始化(产生空串)字符串S
void InitString(pHString S)
{ 
	S->ch = NULL;
	S->length = 0;	
}

//2、将S清为空串
void ClearString(pHString S)
{ 
	free(S->ch);
	S->ch = NULL;
	S->length = 0;
}
//3、生成一个其值等于串常量chars的串S
void StrAssign(pHString S, char *chars)
{
	int i, j;
	if (S->ch)//若S的指针不为空则释放S指针域所指向的空间
		free(S->ch); // 释放S原有空间
	i = strlen(chars); // 求chars的长度i
	if (!i)//若果字符串为空则清空S（相当于复制了一个空字符串）
	{ // chars的长度为0
		S->ch = NULL;
		S->length = 0;
	}
	else
	{ // chars的长度不为0
		S->ch = (char*)malloc(i * sizeof(char)); // 分配大小跟chars大小相同的串空间
		if (!S->ch) // 分配串空间失败
			exit(-1);
		for (j = 0; j < i; j++) // 复制串
			S->ch[j] = chars[j];
		S->length = i;
	}
}
//4、显示字符串
void StrShow(pHString S)
{ 
	int i;
	for (i = 0; i < S->length; i++)
		printf("%c", S->ch[i]);
	printf("\n");
}
//5、复制串S到T
void StrCopy(pHString T,pHString S )
{
	if (T->ch)
		free(T->ch); // 释放T原有空间
	T->ch = (char *)malloc(S->length*(sizeof(char)));//申请内存
	if (T->ch == NULL)
	{
		printf("内存分配失败！");
		exit(-1);
	}
	for (int i = 0; i < S->length; i++)//逐一复制
	{
		T->ch[i] = S->ch[i];
	}
	T->length = S->length;//复制串长
	
}
//6、判断串是否为空，若为空返回True，否则返回false
bool StrEmpty(pHString S)
{
	if (S->length==0&&S->ch==NULL)//空串标志
	{
		return true;
	}
	else
	{
		return false;
	}
}
//7、比较两个串的最前面字符的ASCII码的大小，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0 
int StrCompare(pHString S, pHString T)
{
	for (int i = 0; i < S->length&&T->length; i++)
	{
		if (S->ch[i]!=T->ch[i])//逐一比较字符
		{
			return	S->ch[i] - T->ch[i];//一旦不相等，则返回不想等字符的ASCII码的差值
		}
	}
	return S->length - T->length;//如果全部相等则返回其长度差值
}
//8、返回S的元素个数，称为串的长度
int StrLength(pHString &S)
{ 
	return S->length;
}
//9、用T返回由S1和S2联接而成的新串
void StrConcat(pHString S1, pHString S2, pHString T)
{

	if (T->ch)
		free(T->ch); // 释放T原有空间
	T->ch = (char *)malloc((S1->length + S2->length)*(sizeof(char)));//申请内存
	if (T->ch == NULL)
	{
		printf("内存分配失败！");
		exit(-1);
	}
	for (int i = 0; i < S1->length; i++)//逐一复制S1
	{
		T->ch[i] = S1->ch[i];
	}
	for (int i = 0; i < S2->length; i++)//接着逐一复制S2
	{
		T->ch[S1->length +i] = S2->ch[i];
	}
	T->length = (S1->length + S2->length);//复制总串长
}

//10、用Sub返回串S的第pos个字符起(包括pos位置处的字符)长度为len的子串。
bool StrSub(pHString Sub,pHString S,int pos,int len)
{
	if (StrEmpty(S))
	{
		return	false;
	}
	if (pos<1||pos>S->length||len<0||len>S->length-pos+1)//排除不符合条件的pos和len
	{
		return	false;
	}
	if (Sub->ch)
		free(Sub->ch); // 释放旧空间
	if (!len) // 空子串
	{
		Sub->ch = NULL;
		Sub->length = 0;
	}
	else
	{
		Sub->ch = (char*)malloc(len * sizeof(char));//申请len个空间
		if (!Sub->ch)
			exit(-1);
	}
	for (int i = pos; i < pos+len; i++)//逐个复制
	{
		Sub->ch[i - pos] = S->ch[i-1];
	}
	Sub->length = len;//保存长度
	return true;
}
//11、找出子串T值在主串S中的位置（与子串首字符相等的位置）
int Index1(pHString S, pHString T)
{
	int i,j;
	for (i = 0; i < S->length; i++)//循环主串
	{
		if (S->ch[i] == T->ch[0])//如果在主串中找到一个与子串的第一个字符相等的字符时
		{
			int cont = 1;//计数变量
			for (j = 0; j < T->length; j++)//遍历子串
			{
				if (T->ch[j + 1] != S->ch[i + j+1])//在遍历T[0]时如果有不一致时退出遍历
				{
					break;
				}
				else//否则计数
				{
					cont++;
					if (cont == T->length)//当有T[0]个字符相同时则找到子串位置
						return i+1;
				}
			}
		}
		continue;
	}
	return 0;//不存在时
}

//12、返回子串T在主串S中第pos个字符之后的位置。若不存在，则函数值为0,其中，T非空，1≤pos≤StrLength(S)。
int Index2(pHString S, pHString T, int pos)
{
	int i, j;
	if (1 <= pos && pos <= S->length)
	{
		i = pos;//从主串的第pos个字符开始和子串的第一个字符比较
		j = 0;
		while (i <= S->length && j < T->length)
		{
			if (S->ch[i] == T->ch[j]) // 若找到主串字符与子串首字符相等时继续比较后继字符
			{
				++i;
				++j;
			}
			else // 指针后退，主串字符下标后移一位，重新开始匹配
			{
				i = i + 1;
				j = 0;
			}
		}
		if (j == T->length)//条件成立，子串在主串中
			return i - T->length+1;//因为i是下标，下标编程序号需要+1
		else
			return 0;
	}
	else
		return 0;
}

//13、从串S中删除第pos个字符起长度为len的子串,从新申请空间
bool StrDelete1(pHString S, int pos, int len)
{
	if (StrEmpty(S))//S为空时
	{
		return	false;
	}
	if (pos<1||pos>S->length||len<0||len>S->length-pos+1)//pos和len不满足条件时
	{
		return false;
	}
	char *pNew = (char*)malloc((S->length - len) * sizeof(char));//从新申请空间
	if (pNew==NULL)//申请失败
	{
		return false;
	}
	for (int i = 0; i < pos-1; i++)//复制pos前的字符
	{
		pNew[i] = S->ch[i];
	}
	for (int i = pos+len-1; i < S->length; i++)//复制pos+len-1后的字符
	{
		pNew[i-len] = S->ch[i];
	}
	free(S->ch);//释放原内存
	S->ch = pNew;
	S->length = S->length - len;//更新长度
	return true;
}
//14、从串S中删除第pos个字符起长度为len的子串，调整内存空间
bool StrDelete2(pHString S, int pos, int len)
{
	int i;
	if (StrEmpty(S))//S为空时
	{
		return	false;
	}
	if (S->length < pos + len - 1)//pos和len不满足条件时
		return false;
	for (i = pos - 1; i <= S->length - len; i++)//从pos + len - 1起，之后的元素向前移动
		S->ch[i] = S->ch[i + len];
	S->length -= len;
	S->ch = (char*)realloc(S->ch, S->length * sizeof(char));//调整S->ch的空间
	return true;
}
淡定的炮仗
关注
  • 20
    点赞
  • 踩
  • 106
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
串结构之堆分配存储详解（C语言版）
qq_44075108的博客
04-03 9133
串结构之堆分配存储详解（C语言版）
串的堆分配存储表示
Mekeater的博客
03-12 7457
串的堆分配存储表示 前言 1、串的定长顺序存储结构的缺点是限定了串的长度，若超出长度则约定截断 2、堆分配存储表示解决上上面的问题，它动态分配串值得存储空间 3、串值共享的存储空间称之为堆，它由C语言的动态分配函数malloc和free管理 一、该结构最小操作子集代码实现如下 在这里插入代码片 ...
数据结构(C语言版)----------串的堆分配C语言实现
weixin_43482612的博客
11-07 609
实现代码 #include <cstdio>//printf();scanf() #include <cstdlib>//exit();malloc() #include<string.h> #include<iostream> using namespace std; //函数结束状态代码 #define OVERFLOW -1 #define...
串的存储结构(代码)+算法
qq_63278226的博客
09-22 101
子串的定位运算通常称为串的模式匹配或串匹配。
【数据结构】串的堆分配实现
man_zuo的博客
10-02 1001
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int Status; typedef struct{ char* ch;...
笔记-数据结构.docx
08-07
数据结构笔记 数据结构是一门基础学科，它是计算机科学和技术的核心组成部分。数据结构是指在计算机中存储、组织和管理数据的方式，它是计算机程序设计和算法实现的基础。 一、 线性表 线性表是数据结构的基本...
数据结构笔记-《考研王道笔记知识点整理》
05-23
《考研王道笔记知识点整理》中的内容涵盖了数据结构的基础概念、数据结构的三要素、算法的基本概念以及线性表的定义。 1. **数据结构的基本概念**： - 数据是描述客观事物属性的符号集合，数据元素是数据的基本...
考研复习知识笔记-数据结构
04-16
数据结构笔记-考研复习 数据结构是计算机科学中的一门重要学科，研究如何组织、存储和使用数据。下面是考研复习笔记中的一些重要知识点： 1. 数据结构定义：数据结构是指数据元素之间的逻辑关系、数据的运算和存储...
数据结构与算法-学习笔记 Java 版.zip
最新发布
01-15
例如，数组的连续存储，链表的动态分配节点，树和图的邻接矩阵或邻接表表示等。 基本操作：针对每种数据结构，定义了一系列基本的操作，包括但不限于插入、删除、查找、更新、遍历等，并分析这些操作的时间复杂度和...
用串的堆分配存储方法实现串的各种基本运算
11-02
用串的堆分配存储方法实现串的各种基本运算
数据结构串（堆分配）的基本操作（C语言.蓝鹰天眼）
weixin_45301057的博客
05-23 2420
1.【实验原理】 （1）串(String)(字符串)是由零个或多个字符组成的有限序列。 一般记为：S=′a1a2...an′(n≥0)，其中S是串的名字； 用单引号括起来的字符序列是串的值，ai(1≤i≤n)可以是字母、数字或其它字符； n是串中字符的个数, 称为串的长度； n=0时的串称为空
数据结构（12.3）串之堆分配顺序串
小姚的博客
01-31 1055
堆分配顺序串是串的顺序存储结构的一种，是可以动态分配内存的顺序存储结构
JVM面试题整理
qq_43570075的博客
09-26 210
1. JVM 的主要组成部分及其作用？ 组成部分： Class loader(类装载)子系统：根据给定的全限定名类名来装载class文件到Runtime data area（运行时数据区域）中的method area（方法区）。 Execution engine（执行引擎）：执行classes中的指令。 Native Interface(本地接口)：与native libraries（本地方法库）交互，是其它编程语言交互的接口。 Runtime data area(运行时数据区域)：JVM的内存。 作用
【数据结构 严蔚敏版】 串的堆分配存储 基本操作
热门推荐
Friday
12-22 1万+
串的堆分配存储表示的特点是，仍以一组地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配的。使用动态分配函数malloc()和函数free()来管理存储空间的大小。 串的堆分配存储方法具有顺序存储的特点，又弥补了定长存储的大小限制，多以多被采用。 //文件名：串操作----堆分配存储实现 //描述：这个存储的特点是，仍以一组地址连续的存储单元存放串值字符序列，但是存储空...
串——堆分配存储表示
阿基美德的博客
06-01 795
串的堆分配表示
数据结构_串的堆分配存储表示及KMP算法
m0_65516813的博客
10-26 504
数据结构_串的堆分配存储表示及KMP算法
数据结构 | 串的实现（堆分配存储表示法）
weixin_30299539的博客
05-21 392
———————————————————————————————————————————— 堆分配存储表示法 ———————————————————————————————————————————— 存储结构： 构建堆来存储字符串，本质上是顺序表 ———————————————————————————————————————————— 实现代码： 1 #...
字符串---串的堆分配存储结构
qq_43228581的博客
01-17 1265
@Adrian 串的堆分配存储，其具体实现方式是采用动态数组存储字符串。 通常，编程语言会将程序占有的内存空间分成多个不同的区域，程序包含的数据会被分门别类并存储到对应的区域。拿 C 语言来说，程序会将内存分为 4 个区域，分别为堆区、栈区、数据区和代码区，其中的堆区是本节所关注的。 与其他区域不同，堆区的内存空间需要程序员手动使用 malloc 函数申请，并且在不用后要手动通过 free 函数将...
初旭的《算法与数据结构》笔记-PKU1
08-04
绪论1．1需要记住的东西一、基本术语1、数据在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。2、数据元素：数据的基本单位，在计算机程序中通

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值