C语言数据结构：串的表示和实现,采用动态分配的链式存储结构（未使用string.h)

最新推荐文章于 2024-09-07 11:53:47 发布
最新推荐文章于 2024-09-07 11:53:47 发布
阅读量55 收藏
点赞数
分类专栏： 数据结构 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71709382/article/details/132132046
版权

完整代码：

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2

//给int定义别名为status，当函数返回值是为状态码时，可用status作为函数类型，更方便理解
typedef int Status;

//定义串的结构体，采用动态分配的链式存储结构
typedef struct
{
    char *ch;//若是非空串根据串长分配存储空间，否则ch为NULL
    int length;//串的长度
}HString;

//生成一个其值等于串常量chars的串T
Status AssignStr(HString *T,char *chars);

//由串S复制得串T
Status CopyStr(HString T,HString *S);

//判断串S是否为空串
Status EmptyStr(HString S);

//返回串S的元素个数，称为串的长度
int LengthStr(HString S);

//比较串S与串T的大小，S>T，返回值大于零，S=T，返回值等于零，S<T,返回值小于零
int CompareStr(HString S,HString T);

//将串S清为空串，并释放所占空间
Status ClearStr(HString *S);

//用串T返回由串S1和串S2联接而成的新串
Status ConcatStr(HString *T,HString S1,HString S2);

//用串Sub返回串S的第pos个字符起长度为len的子串
Status SubStr(HString *Sub,HString S,int pos,int len);

//在串S的第pos个字符前插入串T
Status InsertStr(HString *S,int pos,HString T);

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

//用串V替换主串S中出现的所有与串T相等的不重叠的子串
Status ReplaceStr(HString *S,HString T,HString V);

//串的模式匹配,返回值为第一次出现的位置,其中子串为T,主串为S
int IndexStr(HString S,HString T,int pos);

int main(){
    HString str1,str2;
    HString T;
    HString Sub;
    char chars1[]="Hello,World!";
    char chars2[]="ll";
    char chars3[]="Helll,World!";
    //给三个串赋值
    AssignStr(&str1,chars1);
    AssignStr(&str2,chars2);
    AssignStr(&T,chars3);
    printf("str1.ch = %s\n", str1.ch);
    printf("str1.length = %d\n",LengthStr(str1));
    printf("str2.ch = %s\n", str2.ch);
    printf("str2.length = %d\n",LengthStr(str2));
    printf("T.ch = %s\n", T.ch);
    printf("T.length = %d\n", LengthStr(T));
    printf("T是否为空:%d\n",EmptyStr(T));

    printf("比较str1与T大小:%d\n",CompareStr(str1,T));

    //联接str1和str2为T
    ConcatStr(&T,str1,str2);
    printf("T.ch = %s\n", T.ch);
    printf("T.length = %d\n", LengthStr(T));
    printf("T是否为空:%d\n",EmptyStr(T));

    //把str2的值复制给T
    CopyStr(str2,&T);
    printf("------------------\n");
    printf("T.ch = %s\n", T.ch);
    printf("T.length = %d\n", LengthStr(T));

    //用串Sub返回串str的第7个字符起长度为5的子串
    SubStr(&Sub, str1,7,5);
    printf("Sub.ch = %s\n", Sub.ch);
    printf("Sub.length = %d\n", LengthStr(Sub));
    printf("Sub是否为空:%d\n",EmptyStr(Sub));

    //在串Sub的第2个字符前插入串str2
    InsertStr(&Sub,2,str2);
    printf("插入后Sub.ch = %s\n", Sub.ch);
    printf("插入后Sub.length = %d\n", LengthStr(Sub));
    //删除串Sub的第1个字符
    DeleteStr(&Sub,1,1);
    printf("删除后Sub.ch = %s\n", Sub.ch);
    printf("删除后Sub.length = %d\n", LengthStr(Sub));

    printf("------------------\n");
    //将str1与T进行匹配，str1为主串，T为子串
    printf("T.ch = %s\n", T.ch);
    printf("T.length = %d\n", LengthStr(T));
    printf("str1.ch = %s\n", str1.ch);
    printf("str1.length = %d\n",LengthStr(str1));
    printf("第一次出现的位置为%d\n", IndexStr(str1,T,1));

    //用串Sub替换主串str1中出现的所有与串T相等的不重叠的子串
    printf("Sub.ch = %s\n", Sub.ch);
    printf("Sub.length = %d\n", LengthStr(Sub));
    ReplaceStr(&str1,T,Sub);
    printf("str1.ch = %s\n", str1.ch);
    printf("str1.length = %d\n",LengthStr(str1));

    //清空串T
    ClearStr(&T);
    printf("------------------\n");
    printf("T.ch = %s\n", T.ch);
    printf("T.length = %d\n", LengthStr(T));
    printf("T是否为空:%d\n",EmptyStr(T));

}

//生成一个其值等于串常量chars的串T
Status AssignStr(HString* T, char* chars)
{
    int len = 0;
    //求出串chars的长度
    while (chars[len] != '\0')
        len++;

    //多分配一个字节来存储空字符'\0'
    T->ch = (char*)malloc((len + 1) * sizeof(char));
    if (!T->ch)
        exit(OVERFLOW);
    //chars中最后一个字符为'\0',在循环中已经添加复制到T中去了
    for (int i = 0; i <= len; i++)
        T->ch[i] = chars[i];
    
    T->length = len;
    return OK;
}
//由串S复制得串T
Status CopyStr(HString S, HString* T)
{
    T->ch = (char*)malloc((S.length + 1) * sizeof(char));
    if (!T->ch)
        exit(OVERFLOW);
    
    for (int i = 0; i <= S.length; i++)
        T->ch[i] = S.ch[i];
    
    T->length = S.length;
    return OK;
}
//判断串S是否为空串
Status EmptyStr(HString S)
{
    if (S.length == 0)
        return TRUE;
    else
        return FALSE;
}
//返回串S的元素个数，称为串的长度
int LengthStr(HString S)
{
    return S.length;
}
//比较串S与串T的大小，S>T，返回值大于零，S=T，返回值等于零，S<T,返回值小于零
int CompareStr(HString S, HString T)
{
    for (int i = 0; i < S.length && i < T.length; i++)
    {
        if (S.ch[i] < T.ch[i])
            return -1;
        else if (S.ch[i] > T.ch[i])
            return 1;
    }
    //如果循环遍历结束前不能判断两串的大小，就比较两串的长度
    if (S.length < T.length)
        return -1;
    else if (S.length > T.length)
        return 1;
    return 0;
}
//将串S清为空串，并释放所占空间
Status ClearStr(HString* S)
{
    if (S->ch)
    {
        free(S->ch);
        S->ch = NULL;
    }
    S->length = 0;
    return OK;
}
//用串T返回由串S1和串S2联接而成的新串
Status ConcatStr(HString* T, HString S1, HString S2)
{
    T->ch = (char*)malloc((S1.length + S2.length + 1) * sizeof(char));
    if (!T->ch)
        exit(OVERFLOW);
    for (int i = 0; i < S1.length; i++)
        T->ch[i] = S1.ch[i];
    //i <= S2.length这里加等于号是因为要把S2中的'\0'添加到T中
    for (int i = 0; i <= S2.length; i++)
        T->ch[S1.length + i] = S2.ch[i];
    T->length = S1.length + S2.length;
    return OK;
}
//用串Sub返回串S的第pos个字符起长度为len的子串
Status SubStr(HString* Sub, HString S, int pos, int len)
{
    //判断pos与len的值是否合法，S.length - pos并没有算上第pos个字符，所以在判断时要再加上1
    if (pos < 1 || pos > S.length || len < 0 || len > S.length - pos + 1)
        return ERROR;
    Sub->ch = (char*)malloc((len + 1) * sizeof(char));
    if (!Sub->ch)
        exit(OVERFLOW);
    for (int i = 0; i < len; i++)
        Sub->ch[i] = S.ch[pos - 1 + i];
    Sub->ch[len] = '\0';
    Sub->length = len;
    return OK;
}
//在串S的第pos个字符前插入串T
Status InsertStr(HString* S, int pos, HString T)
{
    if (pos < 1 || pos > S->length + 1)
        return ERROR;
    //重新分配存储空间
    S->ch = (char*)realloc(S->ch, (S->length + T.length + 1) * sizeof(char));
    if (!S->ch)
        exit(OVERFLOW);
    //把第pos个字符及之后的字符往后移动T.length位
    for (int i = S->length - 1; i >= pos - 1; i--)
        S->ch[i + T.length] = S->ch[i];
    //在第pos个字符前插入串T
    for (int i = 0; i < T.length; i++)
        S->ch[pos - 1 + i] = T.ch[i];
    S->length += T.length;
    return OK;
}
//从串S中删除第pos个字符起长度为len的子串(包括第pos个字符)
Status DeleteStr(HString* S, int pos, int len)
{
    if (pos < 1 || pos >= S->length || len <= 0 || len > S->length - pos + 1)
        return ERROR;
    //将串S第pos+len个字符后的字符往前移len位
    //因为i < S->length，并非<=,所以不能添加'\0'
    for (int i = pos - 1 + len; i < S->length; i++)
        S->ch[i - len] = S->ch[i];
    S->ch = (char*)realloc(S->ch, (S->length - len + 1) * sizeof(char));
    if (!S->ch)
        exit(OVERFLOW);
    S->length -= len;
    //最后添加'\0'为串的结束
    S->ch[S->length] = '\0';
    return OK;
}
//串的模式匹配,返回值为第一次出现的位置,其中子串为T,主串为S
int IndexStr(HString S, HString T, int pos)
{
    //T.length > S.length - pos + 1如果T的长度比要比需要进行匹配的剩余字符的长度长，那就不可能匹配成功
    if (pos < 1 || pos > S.length || T.length > S.length - pos + 1)
        return -1;
    //i相当于指向串S的指针，j相当于指向串T的指针
    int i = pos - 1;
    int j = 0;
    while (i < S.length && j < T.length)
    {
        //继续比较后继字符
        if (S.ch[i] == T.ch[j])
        {
            //如果相等，两串的指针都后移继续比较
            i++;
            j++;
        }
        else
        {
            //如果不相等，串S的指针后移至其本轮匹配开始时i的位置的后一位，串T的指针回到其第一个字符
            i = i - j + 1;
            j = 0;
        }
    }
    //j >= T.length表示全部匹配成功，就返回成功这次i开始匹配的位置
    if (j >= T.length)
        return i - T.length + 1;
    else
        return -1;
}
//用串V替换主串S中出现的所有与串T相等的不重叠的子串
Status ReplaceStr(HString* S, HString T, HString V)
{
    //先找出串T第一次出现的位置
    int index = IndexStr(*S, T, 1);
    //然后对该位置的串进行替换(先删除再插入)
    while (index > 0)
    {
        DeleteStr(S, index, T.length);
        InsertStr(S, index, V);
        //替换后，再找串T在串S中下一个出现的位置
        index = IndexStr(*S, T, index + 1);
    }
    return OK;
}

运行截图：

 

C PLUS+
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构——串的链式存储
qq_43564685的博客
05-05 1084
#include<stdio.h> #include<stdlib.h> typedef int Status; typedef struct { char *ch; int length; }HString; Status Get(HString &S) { printf(“请输入长度：”); scanf_s("%d",S.length); printf(“请输入...
数据结构C语言动态分配实现串
Just Insist on doing
07-20 633
说明：堆分配存储实现串时，串并不是以’\0‘， 而是用数据项int length来表示的，所以和传统的c语言操作字符串有所不同。 头文件 #ifndef PILEHEAD_H_INCLUDED #define PILEHEAD_H_INCLUDED #include #include typedef struct {     char* ch ;     in
c语言实现串的存储结构,C语言数据结构——串的链式存储
weixin_35649491的博客
05-18 504
//结构体typedef int Status;typedef struct{char *ch;int length;}HString;//以串存储一个字符数组Status StrAssign(HString &T, char *chars){int i;int len = strlen(chars);if (!len)//初始化{T.ch = NULL;T.length = 0;}els...
数据结构：串(c语言 链串，块链和串的模式匹配KMP算法)
weixin_46015333的博客
05-10 1515
串 定义： 串是特殊的线性表，串(string)是零个或多个字符组成的有限序列。一般记作s=“a1a2…an”，其中s是串名，双引号括起来的字符序列是串值；ai(1≦i≦n)可以是字母、数字或其它字符；串中所包含的字符个数称为该串的长度。 长度为零的串称为空串(EmptyString)，它不包含任何字符。 通常将仅由一个或多个空格组成的串称为空白串(Blank String) 注意：空串和空白串的不同，例如“ ”和“”分别表示长度为1的空白串和长度为0的空串。 子串：串中任意个连续字符组成的子序列。
数据结构：栈-利用栈实现任意进制转换代码（C语言）
master_hunter的博客
01-19 5387
如果你发现数据结构看似难以掌握，我将尽力简化知识，将其转化为我们更容易理解的内容。我会确保你能够理解知识并顺利运用到实践中。作为一个从事数据建模五年的专业人士，我参与了许多数学建模项目，了解各种模型的原理、建模流程和题目分析方法。我希望通过这个专栏让你能够快速掌握各类数学模型、机器学习和深度学习知识，并掌握相应的代码实现。每篇文章都包含实际项目和可运行的代码。我会紧跟各类数模比赛，将最新的思路和代码分享给你，保证你能够高效地学习这些知识。
数据结构实例教程（C语言版）：第4章 字符串的结构分析与应用.ppt
06-24
数据结构实例教程（C语言版）：第4章 字符串的结构分析与应用 本章节主要介绍了数据结构中字符串的结构分析和应用。字符串是零个或多个字符组成的有限序列，串的表示方法为 S=“a1a2…an”，其中 S 是串名；双引号...
数据结构：第4章串B.ppt
06-12
数据结构中的"串"，即字符串（String），是计算机科学中一种重要的数据类型，它由一个或多个字符组成，用于表示文本信息。本章节主要探讨了串的定义、表示和实现，以及串的模式匹配算法。 4.1 串类型的定义： 在...
C语言 数据结构 二叉树的链式存储 基本操作（附输入样例和讲解）
qq_31744851的博客
08-30 3430
代码参照了严蔚敏、吴伟民编写的数据结构（C语言版）。 部分内容参考了这位大佬： https://www.cnblogs.com/cpoint/p/3479788.html 所有代码采用C语言编写。讲解请查看注释。 头文件及宏定义 #include<stdio.h> #include<stdlib.h> #include<math.h> #include<string.h> //#include"链队列.h"//层次遍历时用到 #define OK 1 #
数据结构（C语言版）源代码
12-25
字符串是数据结构中的重要元素，这个文件可能包含字符串处理函数，如字符串比较、拷贝、连接、查找子串等，可能使用了字符数组或动态内存分配来实现。 5. **矩阵表示（code6_AdjMatrix.c）** 在图论中，邻接矩阵...
1. Verilog2. C语言3. 数组4. 关键词5. 模块
lsh11111的博客
09-04 933
在 Verilog 中，这种数组可以使用 FPGA 的分布式 RAM 或者块 RAM（BRAM）来实现，取决于指定的关键词 `distributed` 或 `block`。- `reg` 关键词用于定义寄存器信号，与 `wire` 不同，寄存器信号可以在 `always` 块中被赋值，常用于时序逻辑。`module` 和 `endmodule` 关键词用于定义一个模块，模块的代码写在这两个关键词之间。这行代码定义了一个长度为8的数组，每个元素是 `u32` 类型（通常是 32 位无符号整数）。
C和指针：字符串
最新发布
暮色年华的博客
09-07 780
字符串就是一串零个或多个字符，并且以一个位模式为全0的NUL字节结尾。字符串长度就是字符串中字符数。string为指针常量(const修饰string)，指向的string是常量不能修改。size_t是无符号数，定义在stddef.h。C语言遍历字符串: while(*string++!='\0'){}上面两句不等价，第二个恒真，无符合数-无符合数还是无符合数，恒大于0。
《C Primer Plus》第10 章复习题和编程练习
潇雪的博客
09-07 697
《C Primer Plus》第 10 章复习题和编程练习
C语言 | Leetcode C语言题解之第385题迷你语法分析器
m0_59237910的博客
09-05 367
C语言 | Leetcode C语言题解之第385题迷你语法分析器
C语言程序设计（初识C语言后部分）
2402_85207276的博客
09-04 503
·指针
【数据结构-二位前缀和】【二分查找】【枚举优化】力扣1292. 元素和小于等于阈值的正方形的最大边长
sjsjs11的博客
09-04 897
这道题的精髓在于二分查找的使用，由于我们要找到最大的边长，那么我们是不是通常来想，需要遍历从1到矩阵较短边长度的正方形边长，然后把边长一个个去矩阵中寻找是否有合适的正方形。输入：mat = [[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2],[2,2,2,2,2]], threshold = 1。输入：mat = [[1,1,3,2,4,3,2],[1,1,3,2,4,3,2],[1,1,3,2,4,3,2]], threshold = 4。
数据结构（五）----树（含堆）
weixin_73579966的博客
09-04 1058
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的.1.最上面的称为根结点，它没有前驱结点。2.除了根结点，其余结点被分成多个互不相交的集合，其中每个集合又是一棵子树，这些子树的根节点只有一个前驱，可以有0或多个后继3.树是递归定义的。一棵树：子树不能相交总的来说，二叉树的主要难点在于链式二叉树，而其中最重要的思想在于——递归，把大事化为一个重复递归的小事，而贯穿其中的方法是：画图。
数据结构(6.4_6)——拓扑排序
m0_65240792的博客
09-04 300
AOV网：用顶点表示活动的网。用DAG图(有向无环图)表示一个工程，顶点表示活动，有向边<Vi,Vj>表示活动Vi必须先于vj进行回顾：入度即为以顶点为终点的边的数目 代码思路：通过for循环将所有度为0结点的indgree[]下标压入栈中，并初始化print[]数组，使其所有元素为-1，方便记录，再将count指向第一个print数组元素，任何进行while判断，如果栈不为空，则将栈顶元素i弹出栈并进入print数组，count指向下一个数组元素，再通过for循环遍历图中i的所有邻结点，将其度-1，若
数据结构-栈、队列-详解
2401_86587256的博客
09-04 1150
数据结构初阶部分，栈和队列的详解
数据结构（1）数据结构基础（单向链表）
weixin_68239724的博客
09-03 657
数据结构是一组用来保存一种或多种特定关系的数据的集合。其主要目的是组织和存储数据，以便于高效的访问和修改。程序 = 数据结构 + 算法单向链表是一种线性数据结构，由一系列节点构成，每个节点包含数据部分和指向下一个节点的指针。它是一种灵活的存储方式，相比于数组，单向链表不需要连续的内存空间。
C语言数据结构：第4章-串的存储与运算
在C语言版的数据结构课程中，第四章专门探讨了串（String）这一主题，它是计算机科学中非数值处理的重要组成部分。串作为一种特殊的线性表，其数据元素始终是字符型的，常用于表示文本信息，如汇编程序中的源代码、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值