C语言数据结构--串

最新推荐文章于 2023-11-02 18:36:15 发布
最新推荐文章于 2023-11-02 18:36:15 发布
阅读量542 收藏 3
点赞数 1
文章标签： C
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZL1599292797/article/details/103773616
版权 
#ifndef STRING_H
#define STRING_H

#include"Head.h"

#define MAXSTRLEN 255//顺序存储最大串长
#define CHUNKSIZE 4//块链存储块长

//顺序存储
typedef char SString[MAXSTRLEN + 1];//第一个位置存储串长

//堆分配存储
typedef struct {
	char* ch;
	int length;
}HString;

//块链存储
typedef struct Chunk {
	char ch[CHUNKSIZE];
	struct Chunk* next;
}Chunk;
typedef struct {
	Chunk* head, * tail;//头尾指针
	int curlen;//当前长度
}LString;

//块链串初始化
Status InitLString(LString* S);
//生成值为chars的串
Status SStrAssign(SString* S, char* chars);
Status HStrAssign(HString* S, char* chars);
Status LStrAssign(LString* S, char* chars);

//探空
Status Empty_SString(SString S);
Status Empty_HString(HString S);
Status Empty_LString(LString S);
//比较
Status SStrCompare(SString S, SString T);
Status HStrCompare(HString S, HString T);

//串长
int StrLength(SString S);
int HStrLength(HString S);
int LStrLength(LString S);
//销毁
Status DestoryHString(HString* S);
Status DestoryLString(LString* S);
//清空
Status SStrClear(SString* S);
Status HStrClear(HString* S);
Status LStrClear(LString* S);

//连接S1和S2
Status SStrConnect(SString* S1, SString S2);
Status HStrConnect(HString* S1, HString S2);
Status LStrConnect(LString* S1, LString S2);

//用sub返回S的第pos个字符起长度为len的子串
Status SubSString(SString* sub, SString S, int pos, int len);
Status SubHString(HString* sub, HString S, int pos, int len);
Status SubLString(LString* sub, LString S, int pos, int len);

//返回T在S中第pos个字符后第一次出现的位置，否则返回0
int Index(SString S, SString T, int pos);

//在S的第pos个字符之前插入T
Status SStrInsert(SString* S, SString T, int pos);

//从S中删除第pos个字符起长度为len的子串
Status SStrDelete(SString* S, int pos, int len);

//用V替换S中所有的T
Status Replace(SString* S, SString V, SString T);

//模式匹配,KMP算法
void Get_next(SString T, int next[]);
void Get_nextval(SString T, int nextval[]);
int Index_KMP(SString T, SString S, int pos);

//打印输出
void OutPutSString(SString S);
void OutPutHString(HString S);
void OutPutLString(LString S);

#endif // !STRING_H
#ifndef STRING_C
#define STRING_C

#include"String.h"

//块链串初始化
Status InitLString(LString* S) {
	(*S).head = NULL;
	(*S).tail = (*S).head;
	(*S).curlen = 0;
	return OK;
}

//生成值为chars的串
Status SStrAssign(SString* S, char* chars) {
	int len = strlen(chars);
	(*S)[0] = 0;
	while ((*S)[0] < len && (*S)[0] < MAXSTRLEN) {
		(*S)[(*S)[0] + 1] = chars[(*S)[0]];
		(*S)[0]++;
	}
	return OK;
}
Status HStrAssign(HString* S, char* chars) {
	(*S).length = strlen(chars);
	int i = 0;
	(*S).ch = MALLOC((*S).length, char);
	while (i < (*S).length) {
		(*S).ch[i] = chars[i];
		i++;
	}
	return OK;
}
void InsertLString(LString* S, char c) {
	Chunk* p;
	if (!((*S).curlen % CHUNKSIZE)) {
		if (!(*S).head) {
			(*S).head = MALLOC(1, Chunk);
			(*S).tail = (*S).head;
			(*S).head->next = NULL;
			(*S).curlen = 1;
			(*S).head->ch[0] = c;
		}
		else {
			p = MALLOC(1, Chunk);
			p->ch[0] = c;
			(*S).curlen++;
			(*S).tail->next = p;
			p->next = NULL;
			(*S).tail = p;
		}
	}
	else {
		if ((*S).curlen % CHUNKSIZE)
			(*S).tail->ch[(*S).curlen % CHUNKSIZE] = c;
		else
			(*S).tail->ch[CHUNKSIZE] = c;
		(*S).curlen++;
	}
}
Status LStrAssign(LString* S, char* chars) {
	if (!Empty_LString(*S)) 
		LStrClear(S);
	int i = 0;
	InitLString(S);
	while (chars[i]) {
		InsertLString(S, chars[i]);
		i++;
	}
	return OK;
}

//探空
Status Empty_SString(SString S) {
	return !S[0] ? OK : ERROR;
}
Status Empty_HString(HString S) {
	return S.length;
}
Status Empty_LString(LString S) {
	return S.curlen;
}

//比较
Status SStrCompare(SString S, SString T) {
	int i = 1;
	while (i <= S[0] && i <= T[0])
		if (S[i] > T[i])
			return OK;
		else if (S[i] < T[i])
			return INFEASIBLE;
		else
			i++;
	if (i == S[0])
		if (i == T[0])
			return ERROR;
		else
			return INFEASIBLE;
	else
		return OK;
}
Status HStrCompare(HString S, HString T) {
	S.ch[S.length] = 0;
	T.ch[S.length] = 0;
	return strcmp(S.ch, T.ch);
}
//串长
int StrLength(SString S) {
	return S[0];
}
int HStrLength(HString S) {
	return S.length;
}
int LStrLength(LString S) {
	return S.curlen;
}

//销毁
Status DestoryHString(HString* S) {
	free((*S).ch);
	(*S).ch = NULL;
	(*S).length = 0;
	return OK;
}
Status DestoryLString(LString* S) {
	if ((*S).head) {
		Chunk* p, * q;
		p = (*S).head;
		q = p->next;
		while (q) {
			free(p);
			p = NULL;
			p = q;
			q = q->next;
		}
		free(p);
		p = NULL;
		(*S).head = NULL;
		(*S).tail = (*S).head;
		(*S).curlen = 0;
		return OK;
	}
	return ERROR;
}

//清空
Status SStrClear(SString* S) {
	(*S)[0] = 0;
	return OK;
}
Status HStrClear(HString* S) {
	free((*S).ch);
	(*S).length = 0;
	return OK;
}
Status LStrClear(LString* S) {
	(*S).curlen = 0;
	(*S).head = NULL;
	(*S).tail = (*S).head;
	return OK;
}

//连接S1和S2
Status SStrConnect(SString* S1, SString S2) {
	int newlen = (*S1)[0] + S2[0];
	int len2 = 1;
	if (newlen > MAXSTRLEN)
		newlen = MAXSTRLEN;
	while ((*S1)[0] < newlen) 
		(*S1)[++(*S1)[0]] = S2[len2++];
	return OK;
}
Status HStrConnect(HString* S1, HString S2) {
	(*S1).ch = REALLOC((*S1).ch, ((*S1).length + S2.length), char);
	int i = 0;
	while (i < S2.length) {
		(*S1).ch[(*S1).length + i - 1] = S2.ch[i];
		i++;
	}
	(*S1).length += S2.length;
	return OK;
}
Status LStrConnect(LString* S1, LString S2) {
	Chunk* p, * q, * t;
	int i, j, k;
	i = (*S1).curlen % CHUNKSIZE;
	if (!i) {
		(*S1).tail->next = S2.head;
		(*S1).tail = S2.tail;
	}
	else {
		p = (*S1).tail;
		q = S2.head;
		t = q;
		k = 0;
		j = 0;
		while (k < S2.curlen) {
			p->ch[i++] = q->ch[j++];
			k++;
			if (i == CHUNKSIZE) {
				i = 0;
				p->next = MALLOC(1, Chunk);
				p = p->next;
				p->next = NULL;
			}
			if (j == CHUNKSIZE && k < S2.curlen) {
				q = q->next;
				free(t);
				t = NULL;
				t = q;
			}
		}
	}
	(*S1).curlen += S2.curlen;
	return OK;
}

//用sub返回S的第pos个字符起长度为len的子串
Status SubSString(SString* sub, SString S, int pos, int len) {
	if (pos<1 || (pos + len)>S[0])
		return ERROR;
	(*sub)[0] = 0;
	while ((*sub)[0] < len)
		(*sub)[++(*sub)[0]] = S[pos++];
	return OK;
}
Status SubHString(HString* sub, HString S, int pos, int len) {
	if (pos<1 || (pos + len)>S.length)
		return ERROR;
	(*sub).ch = MALLOC(len, char);
	(*sub).length = 0;
	while ((*sub).length < len) {
		(*sub).ch[(*sub).length] = S.ch[pos + (*sub).length];
		(*sub).length++;
	}
	return OK;
}
Status SubLString(LString* sub, LString S, int pos, int len) {
	if (pos + len > S.curlen || pos < 1)
		return ERROR;
	int i = 0, j = 1, k = 0;
	Chunk* p = S.head, * q;
	for (; j < pos; j++) {
		i++;
		if (i == CHUNKSIZE) {
			i = 0;
			p = p->next;
		}
	}
	InitLString(sub);
	(*sub).curlen = len;
	(*sub).head = MALLOC(1, Chunk);
	(*sub).tail = (*sub).head;
	(*sub).tail->next = NULL;
	for (j = 0; j < len; j++) {
		(*sub).tail->ch[k] = p->ch[i];
		i++; k++;
		if (i == CHUNKSIZE) {
			i = 0;
			p = p->next;
		}
		if (k == CHUNKSIZE&&j+1<len) {
			q = MALLOC(1, Chunk);
			q->next = (*sub).tail->next;
			(*sub).tail->next = q;
			(*sub).tail = q;
			k = 0;
		}
	}
	return OK;
}
//返回T在S中第pos个字符后第一次出现的位置，否则返回0
int Index(SString S, SString T, int pos) {
	int loc1, loc2;
	while (T[0] + pos + 1 <= S[0]) {
		loc1 = pos + 1; loc2 = 1;
		while (loc2 <= T[0])
			if (S[loc1] != T[loc2])
				break;
			else {
				loc1++;
				loc2++;
			}
		if (loc2 == T[0])
			return loc1;
		else
			pos++;
	}
	return 0;
}

//在S的第pos个字符之前插入T
Status SStrInsert(SString* S, SString T, int pos) {
	if (pos<1 || pos>(*S)[0])
		return OK;
	int i = (*S)[0], j;
	while (i >= pos) {
		(*S)[i + T[0]] = (*S)[i];
		i--;
	}
	j = T[0];
	while (j > 0) {
		(*S)[i + T[0]] = T[j];
		i--; j--;
	}
	(*S)[0] += T[0];
	return OK;
}

//从S中删除第pos个字符起长度为len的子串
Status SStrDelete(SString* S, int pos, int len) {
	if (pos<1 || (pos + len)>(*S)[0])
		return ERROR;
	while (pos < (*S)[0] - len) {
		(*S)[pos] = (*S)[pos + len];
		pos++;
	}
	(*S)[0] -= len;
	return OK;
}

//用V替换S中所有的T
Status Replace(SString* S, SString V, SString T) {
	int loc = 0, pos, i, j;
	while (loc <= (*S)[0] - T[0]) {
		pos = Index(*S, T, loc);
		if (pos) {
			SStrDelete(S, pos, T[0]);
			SStrInsert(S, V, pos + 1);
			loc = pos + V[0] - T[0] - 1;
		}
		else
			break;
	}
	return OK;
}

//模式匹配
void Get_next(SString T, int next[]) {
	int i, j;
	next[1] = 0;
	i = 1; j = 0;
	while (i < T[0]) {
		if (!j || T[i] == T[j]) {
			++i;
			++j;
			next[i] = j;
		}
		else
			j = next[j];
	}
}
void Get_nextval(SString T, int nextval[]) {
	int i, j;
	nextval[1] = 0;
	i = 1; j = 0;
	while (i < T[0]) {
		if (!j || T[i] == T[j]) {
			++i;
			++j;
			if (T[i] != T[j])
				nextval[j] = j;
			else
				nextval[j] = nextval[i];
		}
		else
			j = nextval[j];
	}
}
int Index_KMP(SString T, SString S, int pos) {
	int i, j;
	int* next = MALLOC((S[0] + 1), int);
	Get_next(S, next);
	i = 1;
	j = 1;
	while (j <= S[0] && i <= T[0]) {
		if (!j || T[i] == S[j]) {
			i++; j++;
		}
		else
			j = next[j];
	}
	if (j > S[0])
		return i - S[0];
	else
		return 0;
}

//打印输出
void OutPutSString(SString S) {
	int i;
	for (i = 1; i <= S[0]; i++)
		printf("%c", S[i]);
	printf("\n");
}
void OutPutHString(HString S) {
	S.ch[S.length + 1] = 0;
	puts(S.ch);
	printf("\n");
}
void OutPutLString(LString S) {
	int i = 0, j = 0;
	Chunk* p;
	p = S.head;
	while (j < S.curlen) {
		printf("%c", p->ch[i]);
		i++;
		j++;
		if (i == CHUNKSIZE) {
			i = 0;
			p = p->next;
		}
	}
	printf("\n");
}

#endif // ! STRING_C

 

QiQaWgYu
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Sstring类
hwc5201314的博客
09-16 2235
import java.io.*; class Noname22 { //java对直接使用字符串类型做了优化，当两个变量值相同时，第二变量不再新开辟空间 public static void main(String[] args) { String a = "我想当个好人"; String b = "我想当个好人"; if(a == b){ System.out.p...
C语言数据结构——串
我想让你也是一个开心果！
11-04 714
串的定义： 串是由零个或多个字符串组成的有限序列，又叫字符串。 串的长度： （1<=i<=n）可以是字母、数字或其他字符；串中字符的数目n称为串的长度。零个字符的串称为空串，他的长度为0。 串可以是空串，即没有字符，直接由" "表示（注意里面没有空格哦！）。 例如： a=‘BEI’ b=‘JING’ c=‘BEIJING’ d=‘BEI JING’ 则a,b,c,d 它们的长度分别为3，4，7，8；并且a和b都是c和d的子串，a在c和d中的位置都是1，而b在C中的位置是4，在d中的位置则是5.
数据结构：定长顺序串（SString）基本操作的算法描述（C语言）
weixin_70911939的博客
04-06 2875
数据结构：定长顺序串（SString）基本操作的算法描述（C语言）
【数据结构】串（String）
高朗的博客
06-12 504
文章目录知识架构相关代码 知识架构 相关代码 #include <iostream> using namespace std; /** * 1. 串定义 */ //1. 静态数组 #define MAXLEN 255 typedef struct { char ch[MAXLEN]; int length; }SString; // 2. 动态 typedef struct { char *ch; int length; }HString; //
2020-03-29
wyf20000105的博客
03-29 244
哪位数据结构大佬能帮忙看一下这道题： 写一个函数“int strConvert(HString &T1, SString &T2，char* chars) ”，通过复制由chars指向的一个字符串，构造表达相同字符串内容的一个HString字符串和一个SString字符串，并且写一个main函数调用strConvert，将转换出的结果输出。 ...
string类详解
phenix_417的博客
11-01 1020
string类详解
数据结构-C语言
weixin_52972575的博客
12-08 2305
字符串 串的简介 在串的操作中，通常以“串的整体”作为操作对象，如在串中查找某个字串，在串中某个位置插入一个子串，删除一个子串等。 串的存储结构 顺序存储（用的多） 静态定义字符串 //静态定义字符串，在编译时刻就确定了串的大小 #include<stdio.h> #define MAXLEN 255 //串的最大长度 typedef struct{ char ch[MAXLEN+1]; //存储串的一维数组 int length; //串的当前长度
C语言数据结构-顺序表版学生管理系统
09-26
在本项目" C语言数据结构-顺序表版学生管理系统 "中，我们将聚焦于一种基础的数据结构——顺序表，以及如何利用C语言实现一个学生管理系统的具体应用。 顺序表是一种线性数据结构，它的特点是元素在内存中按顺序...
C语言数据结构之串插入操作
01-20
C语言数据结构之串插入操作 实例代码： /* 串的堆分配存储表示 */ #include #include #include #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define OVERFLOW -2 typedef int Status; typedef ...
数据结构c语言版-第4章-串.ppt
11-15
数据结构c语言版-第4章-串.ppt
c语言 数据结构实现之字符串
08-30
C语言数据结构实现之字符串 C语言数据结构实现之字符串是指使用C语言来实现字符串数据结构的相关操作。字符串是一种基本的数据结构，广泛应用于计算机科学和信息技术领域。下面将详细介绍C语言数据结构实现之字符串...
数据结构-C语言版：DS04-串.ppt
06-06
数据结构-C语言版：DS04-串.ppt
SString
11-08 6825
using namespace std; #include #define OK 1 #define ERROR -1 #define TRUE 1 #define FALSE -1 #define MAXSTRLEN 255 /***********************************************************************
C++STL详解（一）—— string类
2021dragon的博客
06-14 6181
文章目录C++STL详解（一） —— sring类一、string的定义方式二、string的插入三、string的拼接四、string的删除五、string的查找六、string的比较七、string的替换八、string的交换九、string的大小和容量十、string中元素的访问十一、string中运算符的使用十二、string中与迭代器相关的函数 C++STL详解（一） —— sring类 本次内容大纲： 一、string的定义方式 string类实现了多个构造函数的重载，常用的构造函数如下： st
数据结构 ------字符串---------
weixin_53618261的博客
11-02 606
串（string）是零个或多个字符组成的有限序列。一般为S="a1a2…an"其中S是串名;双引号括起的字符序列是串值；将串值括起来的双引号本身不属于串，它的作用是避免常与常数或与标识符混淆；ai（1≤i≤n）可以是字母、数字或其他字符；串中所包含的字符个数称为该串的长度。空串是长度为零的串，它不包含任何字符。空白串是仅由一个或多个空格组成的串。串中任意个连续字符组成的子序列称为该串的子串。包含子串的串相应地称为主串。
串的定长顺序存储表示和实现
linlinlin45的博客
03-24 5528
串是零个或多个字符的有限序列，我们可以将其看作是种特殊的线性表，其特殊性在于线性表的数据元素的类型总是字符性，字符串的数据对象约束为字符集。 串的存储方式有三种：定长顺序存储表示、堆分配存储表示、块链存储表示。 本文主要讲解串的定长顺序存储表示及其操作的实现 相关定义及准备 #include<iostream> using namespace std; #define TRUE 1 #...
串的定长顺序存储表示
Bee_Darker的博客
10-28 4631
1.串的定长顺序存储表示 #define   MAXSTRLEN   255              //用户可在255以内定义最大串长 typedef     unsigned  char      SString[MAXSTRLEN +1];     //0号单元存放串的长度 2.基本操作的函数原型 1）初始化 Status InitStr(SString &amp;S)； ...
Unity 【Content Size Fitter】- 聊天气泡自动适配Text文本框大小
当代野生程序猿
02-25 5462
通常在展示人物对话的时候文本的长度是不定的，因此会需要动态的调整对话内容文本框的背景图片的大小，这里以如下这种气泡框的对话为例： 实现该需求涉及到的内容包括Content Size Fitter组件的使用、2D Sprite工具包的使用。 Content Size Fitter组件用于Text文本框，如图所示，我们将Horzontal Fit设为Preferred Size，当我们调整Text文本框中的内容时，其大小会自动进行调整。 注意Rect Transform中Pivot轴心点的设置
C语言数据结构串结构
最新发布
06-26
在C语言中，字符串（String）是一种特殊的数据类型，通常表示为字符数组，用来存储字符序列。它并不是C语言的标准库定义的数据结构，但可以通过基本的数组和指针操作来实现类似的功能。 1. 字符数组：最基本的字符串数据结构是字符数组，比如`char str[] = "Hello";`，这里的str实际上就是一个字符数组，数组的第一个元素通常是空字符'\0'，表示字符串的结束。 2. 指针表示：由于字符串常量实际上是常量字符数组，所以我们可以使用指向数组首元素的指针来表示字符串，如`char *str = "Hello";`。 3. strlen函数：C标准库中的`strlen()`函数用于计算字符串的实际长度，不包括'\0'。 4. 动态内存分配：如果需要动态创建和管理字符串，可以使用`malloc()`或`calloc()`分配内存，如`char *str = malloc(strlen("Hello") + 1);`。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值