数据结构C语言版 串的定长顺序存储表示和实现

合集下载

数据结构串串的基本概念串的存储结构与实现串的模式匹配

数据结构串串的基本概念串的存储结构与实现串的模式匹配
t.ch[i]=s1.ch[i]; for(i=s1.length;i<t.length;i++)
t.ch[i]=s2.ch[i-s1.length]; }
串删除
void strdelete(Hstring &s,int pos,int len) {
if(pos<1||pos>s.length-len+1||len<0||len>s.length){ cout<<"删除位置不合法"<<endl; return;
int flag=0; int i=0,j=1; if(s1[0]+s2[0]<=MAXSTRLEN) {
for(i=1;i<=s1[0];i++) t[i]=s1[i];
for(i=s1[0]+1;i<=s1[0]+s2[0];i++) t[i]=s2[j++];
t[0]=s1[0]+s2[0]; flag=1; //未截断 }
strempty(s) 初始条件:s为一个串 操作结果:若s为空串,则返回1
strcopy(&t,s) 初始条件:s为一个串 操作结果:把串s复制给t
strncpy(&sub,s,pos,len) 初始条件:s为一个串,pos为起始位置, 1≤pos≤strlength(s)-1,len≥0 操作结果:用sub返回串s的第pos个字符开⑩长度为len的子串
例:模式串t=“abcac”和主串s=“ababcabcaccabbc”匹配过程
第三二一 趟 a b a b c a b c a c c a b b c i=112734568901

串的基本操作范文

串的基本操作范文

串的基本操作范文串是一种常见且重要的数据结构,其由一个个字符组成的有序序列。

本文就串的基本操作进行详细介绍,包括串的定义、串的表示方法、串的操作等内容。

一、串的定义串是由零个或多个字符组成的有序序列,其中字符的数目称为串的长度。

串是一种线性结构,通常用于表示文本或字符串。

二、串的表示方法1. 静态数组表示:利用C/C++等编程语言中的字符数组来表示串。

例如,“Hello”可以表示为一个字符数组char str[6] = "Hello",其中str[0]='H',str[1]='e',依此类推。

2. 动态数组表示:利用动态内存分配来创建存储串的数组。

例如,在C++中可以使用string类来表示串。

3.链表表示:采用链表的方式来表示串,每个节点存储一个字符,并用指针链接起来。

三、串的基本操作串具有以下基本操作:1. 求串的长度:即求出串中字符的个数,常用的函数有strlen(,可以直接调用。

例如,strlen("Hello")将返回5,表示串的长度为52. 求子串:从串中截取一个子串。

常用的函数有substr(等。

例如,substr("Hello World", 6, 5)将返回"World",表示从原串中的第6个字符开始,截取长度为5的子串。

3. 拼接串:将两个串拼接起来得到一个新的串。

常用的函数有strcat(,可以直接调用。

例如,strcat("Hello", " World")将返回"Hello World",表示将第二个串拼接到第一个串的末尾。

4. 比较串:判断两个串是否相等。

常用的函数有strcmp(,可以直接调用。

例如,strcmp("Hello", "Hello")将返回0,表示两个串相等。

csdn实现顺序串的各种基本运算的算法

csdn实现顺序串的各种基本运算的算法

csdn实现顺序串的各种基本运算的算法CSND上实现顺序串的各种基本运算的算法顺序串是一种连续存储的线性结构,它由一组字符组成,可以进行多种操作和运算。

本文将介绍如何在CSND上实现顺序串的各种基本运算的算法。

1. 顺序串的定义与表示顺序串是由字符组成的有序序列,可以使用一维数组来表示。

数组的每个元素存储一个字符,通过数组索引来访问和操作。

2. 顺序串的初始化顺序串的初始化就是创建一个空的串,可以通过给数组的第一个元素赋值为结束符号'\0'来实现。

3. 顺序串的赋值顺序串的赋值就是将一个串的值复制给另一个串。

可以通过遍历源串的每个字符,逐个将其赋值给目标串的数组元素来实现。

4. 顺序串的连接顺序串的连接就是将两个串合并成一个新的串。

可以通过遍历第一个串的每个字符,将其依次赋值给目标串的数组元素,然后再遍历第二个串的每个字符,将其依次赋值给目标串的数组元素。

5. 顺序串的比较顺序串的比较就是判断两个串是否相等。

可以通过遍历两个串的每个字符,逐个比较它们的值来实现。

如果遇到不相等的字符,则可以根据它们的ASCII码值的大小关系来确定两个串的大小关系。

6. 顺序串的插入顺序串的插入就是将一个串插入到另一个串的指定位置。

可以通过遍历目标串的每个字符,将其依次向后移动一位,然后将要插入的串的字符依次插入到目标串的指定位置。

7. 顺序串的删除顺序串的删除就是将一个串的指定位置的字符删除。

可以通过遍历要删除的位置之后的每个字符,将其依次向前移动一位,然后将要删除的位置的字符覆盖掉。

8. 顺序串的子串顺序串的子串就是从一个串中截取出一段连续的字符组成的串。

可以通过遍历指定区间内的字符,将它们依次赋值给新的串的数组元素。

9. 顺序串的替换顺序串的替换就是将一个串中的指定字符替换为另一个字符。

可以通过遍历源串的每个字符,判断是否与要替换的字符相等,如果相等则将其替换为目标字符。

10. 顺序串的长度顺序串的长度就是串中字符的个数。

c语言描述-串的基本操作

c语言描述-串的基本操作

c语⾔描述-串的基本操作串的定长顺序存储(部分代码)连接两个串:串的第⼀个空间存储串长#define MIXSIZE 100typedef int Status;typedef char SString[MIXSIZE+1];Status Concat(SString *s3,SString s1,SString s2){if(s1[0]+s2[0]<=MIXSIZE){printf("fgsd\n");for(int i=1;i<=s1[0];i++){*s3[i]=s1[i];}for(int i=s1[0]+1;i<s1[0]+s2[0];i++){*s3[i]=s2[0];}*s3[0]=s1[0]+s2[0];return TRUE;}else if(s1[0]<MIXSIZE&&(s1[0]+s2[0]>MIXSIZE)){printf("fgsd\n");for(int i=1;i<=s1[0];i++){*s3[i]=s1[i];}for(int i=s1[0]+1,j=1;(void)(i<=MIXSIZE),j<=MIXSIZE-s1[0];j++,i++){*s3[i]=s2[j];}*s3[0]=MIXSIZE;return FALSE;}else{for(int i=1;i<=MIXSIZE;i++){*s3[i]=s1[i];}*s3[0]=MIXSIZE;return FALSE;}}求⼦串:void SubString(SString *s3,SString s1,int pos,int len){if(pos<1||len>s1[0]||len<0||len>s1[0]-pos+1)printf("⾮法操作!\n");for(int i=1,j=pos;(void)(i<len),j<pos+len-1;i++,j++){*s3[i]=s1[j];}*s3[0]=len;}串的堆分配存储表⽰#include<stdio.h>#include <stdlib.h>#include<string.h>typedef struct{char *ch;int length;}HString;//将字符串chars复制到字符串T中void StrAssign(HString *T,char *chars){int len = 0;while(*(chars+len)!='\0') //计算串的长度{len++;}if(len==0) //串chars为空的情况{T->ch=NULL;T->length=0;}else{T->ch=(char *)malloc(len * sizeof(char));for(int i=0;i<len;i++){T->ch[i]=*(chars+i);}T->length=len;}}//打印串T元素void Print_str(HString *T ){int i=0;while(i<T->length){printf("%c",T->ch[i++]);}printf("\n");}//返回串长度int StrLength(HString *T){return T->length;}//⽐较两串int StrCompare(HString *T,HString *S ){int i;if(T->length!=S->length){if(T->length>S->length){printf("字符串不等,s1的长度⼤于s2\n");return 1;}else{printf("字符串不等,s1的长度⼩于s2\n");return -1;}}else{for(i=0;i<T->length;i++){if(T->ch[i]>S->ch[i]){printf("长度相等,但s1>s2\n");return 1;}else if(T->ch[i]<S->ch[i]){printf("长度相等,但s1>s2\n");return -1;}}printf("字符串相等\n");return 0;}}//连接两的字符串void Concat(HString *T,HString *s1,HString *s2){T->ch=(char *)malloc((s1->length+s2->length)*sizeof(char)); if(!T->ch)exit(0);for(int i=0;i<s1->length;i++)T->ch[i]=s1->ch[i];}for(int i=s1->length,j=0;i<s1->length+s2->length;i++,j++) {T->ch[i]=s2->ch[j];}T->length=s1->length+s2->length;}//求⼦串void SubString(HString *T,HString *S,int pos,int len){T->ch=(char *)malloc(len*sizeof(char));if(!T->ch)exit(0);for(int i=pos-1,j=0;i<pos+len;i++,j++){T->ch[j]=S->ch[i];}T->length=len;}//清空串void ClearString(HString *T ){if(T->ch){free(T->ch);T->ch=NULL;}T->length=0;}//主函数,可对函数进⾏测试int main(){char s1[100];char s2[100];printf(" 请输⼊字符串s1:\n");gets(s1);printf("请输⼊字符串s2:\n");gets(s2);HString S,S1,S2,*p,*p1,*p2;p=&S; p1=&S1; p2=&S2;StrAssign(p1, s1);//StrAssign(p2, s2);//StrCompare(p1, p2);//Concat(p, p1, p2);//SubString(p, p1, 2, 4);//Print_str(p1);//ClearString(p1);//Print_str(p1);}串的模式匹配算法1、传统算法int Index(HString *T,HString *S, int pos){int j=0;while(pos<T->length&&j<S->length){if(T->ch[pos]==S->ch[j]){pos++;j++;}else{pos=pos-j+2;j=1;}}if(j>=S->length){int len;len=pos-S->length+1;printf("%d",len);return len;}else{return 0;}。

数据结构(C语言版)

数据结构(C语言版)

比较
Prim算法适用于稠密图, Kruskal算法适用于稀疏图;
两者时间复杂度相近,但 Kruskal算法需额外处理并查
集数据结构。
最短路径算法设计思想及实现方法比较
1 2
Dijkstra算法
从源点出发,每次找到距离源点最近的顶点并更 新距离值,直至所有顶点距离确定。适用于不含 负权边的图。
Floyd算法
特殊二叉树
满二叉树、完全二叉树等。
二叉树的遍历与线索化
二叉树的遍历
前序遍历、中序遍历、后序遍历和层 次遍历是二叉树的四种基本遍历方法 。
线索化二叉树
为了方便查找二叉树节点的前驱和后 继,可以对二叉树进行线索化处理, 即在节点的空指针域中存放指向前驱 或后继的指针。
树和森林的遍历与转换
树的遍历
01
串的顺序存储结构
01
02
03
串的顺序存储结构是用 一组地址连续的存储单 元来存储串中的字符序
列的。
按照预定义的大小,为 每个定义的串变量分配 一个固定长度的存储区 ,一般是用定长数组来
定义。
串值的存储:将实际串 长度值保存在数组的0下 标位置,串的字符序列 依次存放在从1开始的数
组元素中。
串的链式存储结构
03
比较
DFS空间复杂度较低,适用于递 归实现;BFS可找到最短路径, 适用于非递归实现。
最小生成树算法设计思想及实现方法比较
Prim算法
从某一顶点开始,每次选择当 前生成树与外界最近的边加入 生成树中,直至所有顶点加入

Kruskal算法
按边权值从小到大排序,依次 选择边加入生成树中,保证不
形成环路。
数据结构(C语言版)

串-数据结构实验报告

串-数据结构实验报告

串-数据结构实验报告串数据结构实验报告一、实验目的本次实验的主要目的是深入理解和掌握串这种数据结构的基本概念、存储方式以及相关的操作算法。

通过实际编程实现串的基本操作,提高对数据结构的理解和编程能力,培养解决实际问题的思维和方法。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理(一)串的定义串是由零个或多个字符组成的有限序列。

在本次实验中,我们主要关注的是字符串。

(二)串的存储方式1、顺序存储定长顺序存储:使用固定长度的数组来存储字符串,长度不足时用特定字符填充。

堆分配存储:根据字符串的实际长度动态分配存储空间。

2、链式存储每个节点存储一个字符,并通过指针链接起来。

(三)串的基本操作1、串的创建和初始化2、串的赋值3、串的连接4、串的比较5、求子串6、串的插入和删除四、实验内容及步骤(一)顺序存储方式下串的实现1、定义一个结构体来表示顺序存储的字符串,包含字符数组和字符串的实际长度。

```cppstruct SeqString {char str;int length;};```2、实现串的创建和初始化函数```cppSeqString createSeqString(const char initStr) {int len = strlen(initStr);SeqString s;sstr = new charlen + 1;strcpy(sstr, initStr);slength = len;return s;}```3、串的赋值函数```cppvoid assignSeqString(SeqString& s, const char newStr) {delete sstr;int len = strlen(newStr);sstr = new charlen + 1;strcpy(sstr, newStr);slength = len;}```4、串的连接函数```cppSeqString concatSeqString(const SeqString& s1, const SeqString& s2) {SeqString result;resultlength = s1length + s2length;resultstr = new charresultlength + 1;strcpy(resultstr, s1str);strcat(resultstr, s2str);return result;}```5、串的比较函数```cppint compareSeqString(const SeqString& s1, const SeqString& s2) {return strcmp(s1str, s2str);}```6、求子串函数```cppSeqString subSeqString(const SeqString& s, int start, int len) {SeqString sub;sublength = len;substr = new charlen + 1;strncpy(substr, sstr + start, len);substrlen ='\0';return sub;}```7、串的插入函数```cppvoid insertSeqString(SeqString& s, int pos, const SeqString& insertStr) {int newLength = slength + insertStrlength;char newStr = new charnewLength + 1;strncpy(newStr, sstr, pos);strcpy(newStr + pos, insertStrstr);strcpy(newStr + pos + insertStrlength, sstr + pos);delete sstr;sstr = newStr;slength = newLength;}```8、串的删除函数```cppvoid deleteSeqString(SeqString& s, int start, int len) {int newLength = slength len;char newStr = new charnewLength + 1;strncpy(newStr, sstr, start);strcpy(newStr + start, sstr + start + len);delete sstr;sstr = newStr;slength = newLength;}```(二)链式存储方式下串的实现1、定义一个节点结构体```cppstruct LinkNode {char data;LinkNode next;LinkNode(char c) : data(c), next(NULL) {}};```2、定义一个链式存储的字符串类```cppclass LinkString {private:LinkNode head;int length;public:LinkString(const char initStr);~LinkString();void assign(const char newStr);LinkString concat(const LinkString& other);int compare(const LinkString& other);LinkString subString(int start, int len);void insert(int pos, const LinkString& insertStr);void deleteSub(int start, int len);};```3、实现各个函数```cppLinkString::LinkString(const char initStr) {length = strlen(initStr);head = NULL;LinkNode p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(initStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString::~LinkString(){LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}}void LinkString::assign(const char newStr) {//先释放原有的链表LinkNode p = head;while (p) {LinkNode temp = p;p = p>next;delete temp;}length = strlen(newStr);head = NULL;p = NULL;for (int i = 0; i < length; i++){LinkNode newNode = new LinkNode(newStri);if (head == NULL) {head = newNode;p = head;} else {p>next = newNode;p = p>next;}}}LinkString LinkString::concat(const LinkString& other) {LinkString result;LinkNode p1 = head;LinkNode p2 = otherhead;LinkNode p = NULL;while (p1) {LinkNode newNode = new LinkNode(p1->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p1 = p1->next;}while (p2) {LinkNode newNode = new LinkNode(p2->data);if (resulthead == NULL) {resulthead = newNode;p = resulthead;} else {p>next = newNode;p = p>next;}p2 = p2->next;}resultlength = length + otherlength;return result;}int LinkString::compare(const LinkString& other) {LinkNode p1 = head;LinkNode p2 = otherhead;while (p1 && p2 && p1->data == p2->data) {p1 = p1->next;p2 = p2->next;}if (p1 == NULL && p2 == NULL) {return 0;} else if (p1 == NULL) {return -1;} else if (p2 == NULL) {return 1;} else {return p1->data p2->data;}}LinkString LinkString::subString(int start, int len) {LinkString sub;LinkNode p = head;for (int i = 0; i < start; i++){p = p>next;}for (int i = 0; i < len; i++){LinkNode newNode = new LinkNode(p>data);if (subhead == NULL) {subhead = newNode;} else {LinkNode temp = subhead;while (temp>next) {temp = temp>next;}temp>next = newNode;}p = p>next;}sublength = len;return sub;}void LinkString::insert(int pos, const LinkString& insertStr) {LinkNode p = head;for (int i = 0; i < pos 1; i++){p = p>next;}LinkNode insertHead = insertStrhead;while (insertHead) {LinkNode newNode = new LinkNode(insertHead>data);newNode>next = p>next;p>next = newNode;p = p>next;insertHead = insertHead>next;}length += insertStrlength;}void LinkString::deleteSub(int start, int len) {LinkNode p = head;for (int i = 0; i < start 1; i++){p = p>next;}LinkNode temp = p>next;for (int i = 0; i < len; i++){LinkNode delNode = temp;temp = temp>next;delete delNode;}p>next = temp;length = len;}```(三)测试用例1、顺序存储方式的测试```cppint main(){SeqString s1 = createSeqString("Hello");SeqString s2 = createSeqString("World");SeqString s3 = concatSeqString(s1, s2);std::cout <<"连接后的字符串: "<< s3str << std::endl; int cmpResult = compareSeqString(s1, s2);if (cmpResult < 0) {std::cout <<"s1 小于 s2" << std::endl;} else if (cmpResult == 0) {std::cout <<"s1 等于 s2" << std::endl;} else {std::cout <<"s1 大于 s2" << std::endl;}SeqString sub = subSeqString(s1, 1, 3);std::cout <<"子串: "<< substr << std::endl; insertSeqString(s1, 2, s2);std::cout <<"插入后的字符串: "<< s1str << std::endl; deleteSeqString(s1, 3, 2);std::cout <<"删除后的字符串: "<< s1str << std::endl; return 0;}```2、链式存储方式的测试```cppint main(){LinkString ls1("Hello");LinkString ls2("World");LinkString ls3 = ls1concat(ls2);std::cout <<"连接后的字符串: ";LinkNode p = ls3head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;int cmpResult = ls1compare(ls2);if (cmpResult < 0) {std::cout <<"ls1 小于 ls2" << std::endl;} else if (cmpResult == 0) {std::cout <<"ls1 等于 ls2" << std::endl;} else {std::cout <<"ls1 大于 ls2" << std::endl;}LinkString sub = ls1subString(1, 3);std::cout <<"子串: ";p = subhead;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1insert(2, ls2);std::cout <<"插入后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;ls1deleteSub(3, 2);std::cout <<"删除后的字符串: ";p = ls1head;while (p) {std::cout << p>data;p = p>next;}std::cout << std::endl;return 0;}```五、实验结果及分析(一)顺序存储方式1、连接操作成功实现,输出了正确连接后的字符串。

数据结构(C语言版CHAP4

数据结构(C语言版CHAP4

结束
第 6 页
4. 1
串的基本概念
3 串的基本操作 串的逻辑结构与线性表一样,都是线性结构。但由于串的应用与线性 表不同,串的基本操作与线性表有很大差别。
1)串赋值操作StrAssign( &T, chars) 功能:将串常量char的值赋给串变量T; 2)复制串操作 StrCopy(&T,S) 功能:由串变量S复制得到串变量T; 3)判空操作 StrEmpty(S) 功能:若为空串,则返回TRUE,否则返回FALSE 4) 串比较操作 StrCompare( S, T) 功能若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值 <0 5)串置空操作 ClearString( &S) 功能:将S清为空串 结束 第 7 页
结束
第 2 页
第四章

第四章

4.1 4.2 4.3
串的基本概念 串存储和实现 串的匹配算法
结束
第 3 页
4. 1
串的基本概念
一、串的定义 1 什么是串 串是一种特殊的线性表,它是由零个或多个字符组成的有限序列, 一般记作 s = ‘a1,a2, a3, ... an’ 其中 s----串名, a1,a2, a3, ... an----串值 串的应用非常广泛,许多高级语言中都把串的作为基本数据类型。在 事务处理程序中,顾客的姓名、地址货物的名称、产地可作为字符串处 理,文本文件中的每一行字符等也可作为字符串处理。
11)串删除操作 StrDelete( &S, pos , len) 功能:从串S中删除第pos个字符起长度len 为子串
结束
第 8 页
4.2
串存储和实现

数据结构(四)串

数据结构(四)串

6
i=9 0 S t
slen
0 长度为4
பைடு நூலகம்
j=3
tlen
1、Brute Force算法: //在主串s中定位子串t,不存在返回-1 int Index(char s[],char t[]) { int i=0,j=0; int slen=strlen(s)-1;//s最大下标号 int tlen=strlen(t)-1; //t最大下标号 while(i<=slen && j<=tlen) if(s[i]==t[j]) { ++i; ++j;} else { i=i-j+1; j=0; } if(j>tlen) return i-tlen-1; else return -1; }
二、串的基本操作 对于串的基本操作,许多高级语言均提供了相应的运算或标准库函数来实现。 C/C++语言中常用的串运算如下: 定义下列几个变量: char s1*20+=“dirtreeformat”,s2*20+=“test.cpp”; char s3[30],*p; int result; (1)求串长(length) int strlen(char *s); //求串的长度 (2)串复制(copy) char *strcpy(char *to,char *from); 该函数将串from复制到串to中,并且返回一个指向串to的开始处的指针。 例如:strcpy(s3,s1); //s3=“dirtreeformat” (3)联接(concatenation) char *strcat(char *to,char *from) 该函数将串from复制到串to的末尾,并且返回一个指向串to的开始处的指针。 例如:strcat(s3,”/”) strcat(s3,s2); //s3=“dirtreeformat/test.cpp”
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
uncut=FALSE;
}
return uncut;
}//Concat
//取子串操作
Status SubString(SString Sub,SString S,int pos,int len){
int i;
if(pos<1||pos>S[0]||len<0||len>S[0]-pos+1)
return ERROR;
void main(){
int pos,len;
SString S1,S2,S3,T,Sub;
char a[10],b[10];
printf("输入两个串分别赋值给S1,S2(串长均小于10):\n");
for(i=S[0];i>=pos;i--){
S[i+T[0]]=S[i];}
for(i=pos;i<pos+T[0];i++){
S[i]=T[i-pos+1];}
S[0]=S[0]+T[0];
return TRUE;
}
else{
for(i=MAXSTRLEN;i>=pos;i++){
S[i]=S[i-T[0]];}
return S[0]-T[0];
}//StrCompare
//求长度操作
int StrLength(SString S){
return S[0];
}//StrLength
//串连接操作
Status Concat(SString T,SString S1,SString S2){
int i;
Status uncut;
if(S[i]==T[j]) {
++i;
++j;
}
else{//指针后退重新开始匹配
i=i-j+2;
j=1;
}
}
if(j>T[0])
return i-T[0];//匹配成功
return 0;//匹配失败
}//Index
//串插入操作
Status StrInsert(SString S,int pos,SString T){
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define MAXSTRLEN 255
typedef int ElemType;
typedef int Status;
typedef unsigned char SString[MAXSTRLEN+1];
//串赋值操作
Status StrAssign(SString T,char chars[]){
//生成一个其值等于chars的串T
int i;
if(strlen(chars)>MAXSTRLEN)
if(S1[0]+S2[0]<=MAXSTRLEN){
for(i=1;i<=S1[0];i++){
T[i]=S1[i];}
for(i=1;i<=S2[0];i++){
T[S1[0]+i]=S2[i];}
T[0]=S1[0]+S2[0];
uncut=TRUE;
}
else if(S1[0]<MAXSTRLEN){
}
printf("\n");
}//PrnStr
//串复制操作
Status StrCopy(SString T,SString S){
//由串S复制得串T
int i;
for(i=1;i<=S[0];i++)
T[i]=S[i];
T[0]=S[0];
returnus StrEmpty(SString S){
return ERROR;
T[0]=strlen(chars);
for(i=0;i<=T[0];i++){
T[i+1]=chars[i];}
return OK;
}//StrAssign
//输出串
void StrPrint(SString S){
int i;
for(i=1;i<=S[0];i++){
printf("%c",S[i]);
for(i=pos;i<pos+T[0];i++){
S[i]=T[i-pos+1];}
S[0]=MAXSTRLEN;
return FALSE;
}
}//StrInsert
//串删除操作
Status StrDelete(SString S,int pos,int len){
//初始条件:串S存在,1≤pos≤StrLength(S)-len+1
for(i=1;i<=S1[0];i++){
T[i]=S1[i];}
for(i=1;i<=MAXSTRLEN-S1[0];i++){
T[S1[0]+i]=S2[i];}
T[0]=MAXSTRLEN;
uncut=FALSE;
}
else{
for(i=0;i<=MAXSTRLEN;i++){
T[i]=S1[i];}
//操作结果:从串S中删除第pos个字符起长度为len的子串
int i;
if(pos<1||pos>S[0]-len+1||len<0)
return ERROR;
for(i=pos+len;i<=S[0];i++){
S[i-len]=S[i];}
S[0]-=len;
return OK;
}//StrDelete
for(i=1;i<=len;i++){
Sub[i]=S[pos+i-1];}
Sub[0]=len;
return OK;
}//SubString
//求子串位置操作
int Index(SString S,SString T,int pos){
int i,j;
i=pos;
j=1;
while(i<=S[0]&&j<=T[0]){
//初始条件:串S和T存在,1≤pos≤StrLength(S)+1
//操作结果:在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE
int i;
if(pos<1||pos>S[0]+1)
return ERROR;
if(S[0]+T[0]<=MAXSTRLEN){ //完全插入
if(S[0]==0)
return OK;
else
return ERROR;
}//StrEmpty
//串比较操作
int StrCompare(SString S,SString T){
int i;
for(i=1;i<=S[0]&&i<=T[0];++i)
if(S[i]!=T[i])
return S[i]-T[i];
相关文档
最新文档