数据结构（C语言）——第四章、串（1）串的顺序存储

最新推荐文章于 2023-09-22 13:57:50 发布
最新推荐文章于 2023-09-22 13:57:50 发布
阅读量704 收藏 20
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43416592/article/details/120102639
版权

目录

说明：串的顺序存储操作，分为静态数组和动态数组两类。两者的操作差别不大，注意看动态数组前面的补充内容。

静态数组

//
// @Author: Brisa
// @Date: 2021/9/4
// @Description: 串的顺序存储
//               静态数组实现（定长顺序存储）
//               舍弃数组0号位，从1开始存取等操作
//
#include<stdio.h>
#include<string.h>

#define MAXLEN 255  //预定义最大串长为255
typedef struct{
    char ch[MAXLEN];  //每个分两存储一个字符
    int length;  //串的实际长度
}SString;

/*函数声明*/
void StrAssign(SString &S, char chars[]);  //1.赋值操作，把串S，赋值为chars
void StrCopy(SString &S, SString T);       //2.复制操作，由串T复制得到S
bool StrEmpty(SString S);                  //3.判空操作，若S为空串返回true，否则返回false
int StrLength(SString S);                  //4.求串长，返回串S的个数
void ClearString(SString &S);              //5.清空操作，将S清为空串
//bool DestroyString(SString &S);          //6.销毁串，将串S销毁（回收存储空间）
void Concat(SString &S, SString T1, SString T2);            //7.串连接，用S返回由T1和T2连接而成的新串
bool SubString(SString &Sub, SString S, int pos, int len);  //8.求子串，用Sub返回串S中的第pos个字符起长度为len的子串
int StrCompare(SString S, SString T);      //9.比较操作，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
int Index(SString S, SString T);           //10.定位操作，若主串S中存在与串T相同的子串，则返回它在子串中第一次出现的位置，否则函数值为0
void InitString(SString &S);               //11.初始化串
void PrintString(SString S);               //12.遍历串


/*基本操作的实现*/
//1.赋值操作，把串S，赋值为chars
void StrAssign(SString &S, char chars[]){
    S.ch[0] = '#';  //0号位舍弃不用
    for(int i=1; i<MAXLEN && i<=strlen(chars); i++) {
        S.ch[i] = chars[i-1];
        S.length++;
    }
    /*
     int i = 0;
     while(chars[i]){
        T.ch[++T.length] = chars[i];
        i++;
    }
     */
}

//2.复制操作，由串T复制得到S
void StrCopy(SString &S, SString T){
    for(int i=1; i<=T.length; i++){
        S.ch[i] = T.ch[i];
    }
    S.length = T.length;
}

//3.判空操作，若S为空串返回true，否则返回false
bool StrEmpty(SString S){
    return S.length == 0;
}

//4.求串长，返回串S的个数
int StrLength(SString S){
    return S.length;
}

//5.清空操作，将S清为空串[逻辑上清空]
void ClearString(SString &S){
    S.length = 0;
}
//6.销毁串，将串S销毁（回收存储空间）
//bool DestroyString(SString &S){}  静态数组，未使用时自动回收空间

//7.串连接，用S返回由T1和T2连接而成的新串
void Concat(SString &S, SString T1, SString T2){
    S.length = 0;
    for(int i=1; i<MAXLEN && i<= T1.length+T2.length; i++){
        if(i <= T1.length){
            S.ch[i] = T1.ch[i];
        } else{
            S.ch[i] = T2.ch[i-T1.length];
        }
        S.length++;

        /*先将S1赋值给T,等价于 StrCopy(T, S1);*/
        /*for (int i = 1; i <= S1.length; i++)
            T.ch[i] = S1.ch[i];
        for (int i = 1; i <= S2.length; i++)
            T.ch[i + S1.length] = S2.ch[i];
        T.length = S1.length + S2.length;
        */
    }
}

//8.求子串，用Sub返回串S中的第pos个字符起长度为len的子串
bool SubString(SString &Sub, SString S, int pos, int len){
    if((pos + len-1) > S.length)//判断子串范围是否越界
        return false;
    for (int i=pos; i <= pos+len-1; i++){
        Sub.ch[i-pos+1] = S.ch[i];
    }
    Sub.length = len;
    return true;
}

//9.比较操作，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
int StrCompare(SString S, SString T){
    for(int i=1; i<=S.length && i<=T.length; i++){
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    }
    //前面的都相等，就比较串长
    return S.length - T.length;
}

//10.定位操作，若主串S中存在与串T相同的子串，则返回它在子串中第一次出现的位置，否则函数值为0
int Index(SString S, SString T){
    int i=1, n=S.length, m=T.length;
    SString Sub; //用于暂存子串
    while(i < n-m+1){
        SubString(Sub, S, i, m);
        /*相当于从S的开头找遍 长度为m 的子串，再与T进行比较*/
        if(StrCompare(Sub, T) != 0) {
            i++;
        } else
            return i; //若相等则返回T在S中的位置
    }
    return 0; //S中不存在与T相等的子串
}

//11.初始化串
void InitString(SString &S){
    S.length = 0;
}

//12.遍历串
void PrintString(SString S){
    int i=1;
    while (i<=S.length)
        printf("%c ", S.ch[i++]);
    printf("\n");
}


int main(){
    //1.定义一个静态定长串
    SString S1;

    //2.初始化该串
    InitString(S1);

    //3.赋值操作
    printf("***开始赋值操作***\n");
    char chars[] = "hello,world";
    StrAssign(S1, chars);
    PrintString(S1);

    //4.复制操作
    printf("***开始复制操作***\n");
    SString S2;
    StrCopy(S2, S1);
    PrintString(S2);

    //5.连接操作
    printf("***开始连接操作***\n");
    SString S3;
    Concat(S3, S1, S2);
    PrintString(S3);

    //6.求子串操作
    printf("***开始求子串操作***\n");
    SString Sub;
    int pos = 3, len = 4;
    if(SubString(Sub, S1, pos, len)){
        printf("所得子串为：");
        PrintString(Sub);
    } else {
        printf("子串范围越界\n");
    }
    //7.比较操作
    printf("***开始比较操作***\n");
    if(StrCompare(S1,S2) == 0){
        printf("S1 = S2\n");
    } else if(StrCompare(S1,S2) > 0){
        printf("S1 > S2\n");
    } else{
        printf("S1 < S2\n");
    }

    //8.定位操作
    printf("***开始定位操作***\n");
    if(Index(S1,Sub) != 0){
        printf("子串Sub在S1中的位置为：%d\n", Index(S1,Sub));
    } else{
        printf("子串Sub不在S1中\n");
    }

    //9.一些其他函数的实现
    printf("S1的长度为：%d\n",StrLength(S1));
    ClearString(S1);
    printf("S1的长度为：%d\n",StrLength(S1));

    return 0;
}

动态数组

//
// @Author: Brisa
// @Date: 2021/9/4
// @Description: 串的顺序存储
//               动态数组实现（堆分配存储）
//               补充：相较于静态数组申请方式，1)只是在销毁串方面有差异，
//                                        2)再就是增加了一个扩大串长的函数,
//                                        3)以及声明了串后，都需要先InitString 初始化一下
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAXLEN 255   //预定义最大串长为255

typedef struct{
    char *ch;  //按串长分配存储区，ch指向串的基地址
    int length;  //串的实际长度
}HString;

/*函数声明*/
void StrAssign(HString &S, char chars[]);  //1.赋值操作，把串S，赋值为chars
void StrCopy(HString &S, HString T);       //2.复制操作，由串T复制得到S
bool StrEmpty(HString S);                  //3.判空操作，若S为空串返回true，否则返回false
int StrLength(HString S);                  //4.求串长，返回串S的个数
void ClearString(HString &S);              //5.清空操作，将S清为空串
void DestroyString(HString &S);            //6.销毁串，将串S销毁（回收存储空间）
void Concat(HString &S, HString T1, HString T2);            //7.串连接，用S返回由T1和T2连接而成的新串
bool SubString(HString &Sub, HString S, int pos, int len);  //8.求子串，用Sub返回串S中的第pos个字符起长度为len的子串
int StrCompare(HString S, HString T);      //9.比较操作，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
int Index(HString S, HString T);           //10.定位操作，若主串S中存在与串T相同的子串，则返回它在子串中第一次出现的位置，否则函数值为0
void InitString(HString &S);               //11.初始化串
void PrintString(HString S);               //12.遍历串
void IncreaseSize(HString& S, int len);    //13.增加串长

/*函数实现*/
//1.赋值操作，把串S，赋值为chars
void StrAssign(HString &S, char chars[]){
    int i = 0;
    while (chars[i])
    {
        S.ch[++S.length] = chars[i];
        i++;
    }
}

//2.复制操作，由串T复制得到S
void StrCopy(HString &S, HString T){
    for(int i=1; i<=T.length; i++){
        S.ch[i] = T.ch[i];
    }
    S.length = T.length;
}

//3.判空操作，若S为空串返回true，否则返回false
bool StrEmpty(HString S){
    return S.length == 0;
}

//4.求串长，返回串S的个数
int StrLength(HString S){
    return S.length;
}

//5.清空操作，将S清为空串(逻辑上清空)
void ClearString(HString &S){
    S.length = 0;
}

//6.销毁串，将串S销毁（回收存储空间）
void DestroyString(HString &S){
    free(S.ch);  //清除掉S.ch
    S.ch = NULL;
}

//7.串连接，用S返回由T1和T2连接而成的新串
void Concat(HString &S, HString T1, HString T2){
    /*先将S1赋值给S2,等价于 StrCopy(T, S1);*/
    for (int i = 1; i <= T1.length; i++)
        S.ch[i] = T1.ch[i];

    for (int i = 1; i <= T2.length; i++)
        S.ch[i + T1.length] = T2.ch[i];
    S.length = T1.length + T2.length;
}


//8.求子串，用Sub返回串S中的第pos个字符起长度为len的子串
bool SubString(HString &Sub, HString S, int pos, int len){
    if((pos + len-1) > S.length)//判断子串范围是否越界
        return false;
    for (int i=pos; i <= pos+len-1; i++){
        Sub.ch[i-pos+1] = S.ch[i];
    }
    Sub.length = len;
    return true;
}

//9.比较操作，若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0
int StrCompare(HString S, HString T){
    for(int i=1; i<=S.length && i<=T.length; i++){
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    }
    //前面的都相等，就比较串长
    return S.length - T.length;
}

//10.定位操作，若主串S中存在与串T相同的子串，则返回它在子串中第一次出现的位置，否则函数值为0
int Index(HString S, HString T){
    int i=1, n=S.length, m=T.length;
    HString Sub; //用于暂存子串
    InitString(Sub);
    while(i < n-m+1){
        SubString(Sub, S, i, m);
        /*相当于从S的开头找遍 长度为m 的子串，再与T进行比较*/
        if(StrCompare(Sub, T) != 0) {
            i++;
        } else
            return i; //若相等则返回T在S中的位置
    }
    return 0; //S中不存在与T相等的子串
}

//11.初始化串
void InitString(HString &S){
    S.ch = (char *)malloc(sizeof(char) * MAXLEN);
    S.length = 0;
}

//12.遍历串
void PrintString(HString S){
    for (int i = 1; i <= S.length; i++)
        printf("%c ", S.ch[i]);
    printf("\n");
}

//13.增加动态数组的长度
void IncreaseSize(HString& S, int len){
    char *p= S.ch;
    S.ch = (char *)malloc(sizeof(char) * (MAXLEN + len));
    for(int i=1; i<= S.length; i++){  //将数据复制到新区域（时间开销大）
        S.ch[i] = p[i];
    }
    S.length += len;  //串长增加len
    free(p); // 释放掉原来的内存空间
}


int main(){
    //1.声明一个动态串
    HString S1;

    //2.初始化一个串
    InitString(S1);

    //3.赋值操作
    printf("***开始赋值操作***\n");
    char chars[] = "hello,world";
    StrAssign(S1, chars);
    PrintString(S1);

    //4.复制操作
    printf("***开始复制操作***\n");
    HString S2;
    InitString(S2);
    StrCopy(S2, S1);
    PrintString(S2);

    //5.连接操作
    printf("***开始连接操作***\n");
    HString S3;
    InitString(S3);
    Concat(S3, S1, S2);
    PrintString(S3);

    //6.求子串操作
    printf("***开始求子串操作***\n");
    HString Sub;
    InitString(Sub);
    int pos = 3, len = 4;
    if(SubString(Sub, S1, pos, len)){
        printf("所得子串为：");
        PrintString(Sub);
    } else {
        printf("子串范围越界\n");
    }
    //7.比较操作
    printf("***开始比较操作***\n");
    if(StrCompare(S1,S2) == 0){
        printf("S1 = S2\n");
    } else if(StrCompare(S1,S2) > 0){
        printf("S1 > S2\n");
    } else{
        printf("S1 < S2\n");
    }

    //8.定位操作
    printf("***开始定位操作***\n");
    if(Index(S1,Sub) != 0){
        printf("子串Sub在S1中的位置为：%d\n", Index(S1,Sub));
    } else{
        printf("子串Sub不在S1中\n");
    }

    //9.一些其他函数的实现
    printf("S1的长度为：%d\n",StrLength(S1));
    ClearString(S1);
    printf("S1的长度为：%d\n",StrLength(S1));

    return 0;
}

参考来源：
数据结构代码参考博客
《王道数据结构》

Brisa56
关注
  • 1
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
串的基础知识
ChanCherry的博客
03-12 1691
定义 串：是由0个或多个字符组成的有限序列，又叫字符串。S=‘a1a2…an’(n>=0) 空串：长度n=0的串，不包含任何字符。 空格串：是仅由一个或多个空格组成的串，长度>=1。 子串：串中任意个连续的字符组成的子序列。 主串：包含子串的串相应的称为主串。 位置：字符在序列中的序号，子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。 相等：两个串的长度相等，并且对应位置的...
《数据结构》（C语言版）——串的定长顺序存储表示
prlhnxx的博客
04-05 2333
/* 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...
数据结构—顺序串 Ⅵ
Miss Z的博客
08-14 1497
数据结构-串(第四章)的整理笔记，若有错误，欢迎指正。 可以参考和对比一下C语言里面的字符串：C语言 字符串 串的基本操作{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
串的存储结构(代码)+算法
qq_63278226的博客
09-22 100
子串的定位运算通常称为串的模式匹配或串匹配。
串的三种存储结构：顺序、链式、索引(基于荣政版数据结构与算法分析)
shuaishuai5213的博客
10-07 2737
串是一种特殊的线性表，所以先得搞清楚线性表的顺序、链式存储，在其基础上便可以清楚分析特殊线性表的存储结构：栈、队列、串 顺序：结构体里面定义一个数组+长度等辅助信息 链式：结构体里面定义一个元素数据类型+结构体指针 顺序串和链串没什么分析的，仅给出定义，主要分析索引存储下的串 顺序串： typedef struct { char ch[MAX]; int len; }seqSting; 链串： typedef struct linkNode { char data; linkNode *next;
C语言课件——第02章数据与运算
05-01
* 整数类型：包括short、int、long和long long四种，分别占2、4、4和8个字节的存储空间。 * 实数类型：包括float、double和long double三种，分别占4、8和12个字节的存储空间。 * 字符类型：char类型占1个字节的存储...
数据结构：第4章串A.ppt
06-12
【数据结构：第4章串A.ppt】的讲解主要围绕计算机科学中数据结构的一个重要概念——"串"，也就是字符串。字符串是由零个或多个字符组成的有限序列，是数据元素为单个字符的特殊线性表。在编程中，字符串处理是常见的...
数据结构c语言版章(与“字符”有关文档共52张).pptx
11-14
《数据结构C语言版》章节主要探讨了与字符相关的数据结构——串（String）的概念、表示与操作。串是由零个或多个字符组成的有限序列，它可以看作是字符的数组。在计算机科学中，串是一种重要的数据结构，广泛应用于...
第1章-c语言学习PPT文档.pptx
11-18
1. **简洁明了**：C语言的关键字数量有限，只有32个，这使得语言结构清晰，易于理解和学习。 2. **强大的表达能力**：尽管简洁，C语言却能有效地表达复杂的计算和逻辑操作，通过9种控制语句和丰富的运算符实现。 3. ...
5 数据结构第三章知识点.doc
最新发布
01-14
本章主要讨论了两种基本的数据结构——栈和队列。 栈是一种“后进先出”（LIFO，Last In First Out）的数据结构，它允许在表的一端进行插入（称为栈顶）和删除操作，而另一端（栈底）通常是固定的。当栈中没有元素...
数据结构之串的定长顺序存储
偶然i的博客
03-13 3021
技术交流qq：1032492413 技术交流VX:Chamfion
顺序存储实现串
weixin_47511190的博客
08-16 211
实现代码： #include<iostream> using namespace std; //顺序存储实现串 #define MaxLen 255 struct String{ char ch[MaxLen]; //存储串的字符元素 int length; //串的长度 }; //初始化串 void InitString(String &S){ S.length=0; } //赋值操作，将字符串chars的值赋值给串S void StringAssign(Str
数据结构笔记——串的存储结构
晓风岚月
05-15 638
目录 一、串的顺序存储 1.静态数组实现（定长顺序存储） 2.动态数组实现 3.存储方式 二、串的链式存储 三、基本操作的实现 1.求子串SubString(&Sub,S,pos,len) 2.比较操作。StrCompare(S,T) 3.定位操作。Index(S,T) 四、总结​ 一、串的顺序存储 1.静态数组实现（定长顺序存储） #define MAXLEN 255 typedef struct{ char ch[MAXLEN]; int length
【数据结构】-串的顺序存储(静态分配）
RunningSnail的博客
08-02 2892
串的定长顺序存储-静态分配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
串String（1）：串的实现（定长顺序存储结构）
aibin6833的博客
07-23 1173
前言 PS:本文相关头文件、预编译以及typedef如下，阅读一遍以便于下面的理解：　　 #include <stdio.h> #include <stdlib.h> #include <string.h> #define MAXSTRLEN 40 #define OK 1 #define ERROR 0 #define ...
数据结构--串的顺序储存
做个假设——坚持两年，我会怎么样
07-29 963
用一组地址连续的存储单元存储串值的字符序列，为每个定义的串变量分配一个固定长度的存储区。 串的实际长度可以在预定长度的范围内随意，超过预定义长度的串值则被舍去，称之为“截断”。 对于串长的表示有两种：一是以下标为0的数组分量存放串的实际长度；二是在串值后面加一个不计入串长的结束标记字符。 这里串的顺序存储使用第一种方式记录串长。 //串的顺序存储方式 #include #include #i
数据结构_串_顺序结构(C语言)
小黯
07-22 1616
目录（一）串（二）串代码解析1、串的基本操作1.01 串的基本结构1.02 串的创建1.03 串的遍历1.04 串的匹配1.05 串的连接1.06 串的比较1.07 串的长度1.08 串的复制1.09 串的清空1.10 串的销毁2、串源代码及测试2.1 源代码：2.2 测试 （一）串 串的顺序结构和顺序表的结构一样， 串的区别仅仅是在顺序表数据类型的区别，串的数据类型是字符型， 接下来我将实现串的一些基本操作，其中一些基本操作类似于头文件< string >的内置函数 （二）串代码解析 1、
数据结构（十五）串的顺序存储结构（顺序串）
weixin_30887919的博客
06-19 889
　　一、串的定义：串（String）是由零个或多个字符组成的有限序列，又名叫字符串。 　　二、串中的字符数目n称为串的长度，零个字符的串称为空串（null string），它的长度为零。子串在主串中的位置就是子串的第一个字符在主串中的序号。 　　三、串的大小：首先比较每个字符对应的ASCII码，然后比较长度n。 　　四、串中关注更多的是查找子串位置、得到指定位置子串、替换子串等操作...
考研数据结构之串（4.4）——练习题之编写一个函数计算一个子串在一个主串中出现的次数，如果该子串不出现，则返回0.（C表示）
二木成林
06-03 1986
题目 编写一个函数，计算一个子串在一个主串中出现的次数，如果该子串不出现，则返回0.本题不考虑子串重叠，如：主串为aaaa，子串为aa，考虑子串重叠结果为2，不考虑子串重叠结果为1。 分析 模式匹配算法的扩展，统计子串的出现次数。 代码 核心代码： /* 计算子串在主串中出现的次数 */ /* str指的是主串；substr指的是子串 */ int index(Str str,Str substr){ int i=0,j=0,sum=0; while(i<str.length&am
c语言实现定长顺序存储,数据结构C语言版串的定长顺序存储表示及实现.doc
05-24
C语言实现定长顺序存储串的方法如下： 首先，我们需要定义一个固定长度的字符数组来存储串，如下所示： ``` #define MAXLEN 100 // 定义最大长度 typedef struct { char data[MAXLEN]; // 存储串的字符数组 int...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值