数据结构之串

已于 2024-07-10 16:15:28 修改
阅读量97 收藏
点赞数 1
分类专栏： codelearning 文章标签： 数据结构
于 2024-07-09 21:18:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62758636/article/details/140277791
版权
串的定义和实现（了解即可）

在这里插入图片描述

code
#include <iostream>
#include <cstring>
using namespace std;
#define MAXLEN 255 // 预定义最大串长为255
// 定长数组实现（定长顺序存储 ）
typedef struct
{
    char ch[MAXLEN]; // 每个分量存储一个字符
    int length;      // 串的实际长度
} SString;

// 动态数组实现（堆分配）
    typedef struct
    {
        char *ch;   // 按串长分配存储区，ch指向串的基地址
        int length; // 串的长度
    } HString;
//串的基本操作：
    // StrAssign(&T, chars)//赋值操作。把串T赋值为 chars
    // Strcopy(&T, S)// 复制操作。由串S复制得到串T。
    // StrEmpty(S)// 判空操作。若S为空串,则返回TRUE,否则返回 FALSE
    // StrCompare(S,T)// 比较操作。若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0。
    // StrEngth(S)// 求串长。返回串S的元素个数
    // Substring(&Sub,S,pos,1en)//求子串。用Sub返回串S的第pos个字符起长度为len的子串。
    // Concat(&T,S1,S2)//串联接。用T返回由S1和S2联接而成的新串。
    // Index(S,T)// 定位操作。若主串S中存在与串T值相同的子串,则返回它在主串S中第一次出现的位置;否则函数值为0
    // Clearstring(&S)// 清空操作。将S清为空串
    // Destroystring(&S)//销毁串。将串S销毁

// 赋值操作。把串T赋值为 chars
void StrAssign(SString *T, char* chars)
{
    int len = strlen(chars);
    if (len > MAXLEN)
        len = MAXLEN; // 确保长度不超过最大值
    for (int i = 0; i < len; i++)
    {
        T->ch[i] = chars[i];
    }
    T->length = len;
}

// 复制操作。由串S复制得到串T。
void Strcopy(SString *T, SString S)
{
    int len = S.length;
    if (len > MAXLEN)
        len = MAXLEN; // 确保长度不超过最大值
    for (int i = 0; i < len; i++)
    {
        T->ch[i] = S.ch[i];
    }
    T->length = len;
}

// 判空操作。若S为空串，则返回TRUE，否则返回 FALSE
int  StrEmpty(SString S)
{
    return S.length == 0;
}

// 比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
int StrCompare(SString S, SString T)
{
    int len1 = S.length, len2 = T.length;
    int min_len = (len1 < len2) ? len1 : len2; // 取较小的长度进行比较
    for (int i = 0; i < min_len; i++)
    {
        if (S.ch[i] > T.ch[i])
            return 1; // S>T，返回1
        if (S.ch[i] < T.ch[i])
            return -1; // S<T，返回-1
    }
    return (len1 - len2); // 若相等，则比较长度差值，正表示S>T，负表示S<T，0表示S=T
}

// 求串长。返回串S的元素个数。
int StrEngth(SString S)
{
    return S.length;
}

// 求子串。用Sub返回串S的第pos个字符起长度为len的子串。
void Substring(SString *Sub, SString S, int pos, int len)
{
    if (pos < 1 || pos > S.length || len < 1 || pos + len > S.length)
    {                    // 边界检查很重要
        Sub->length = 0; // 子串越界，置为空串
        return;
    }

    for (int i = 0; i < len; i++)
    {                                   // 取子串字符到Sub中
        Sub->ch[i] = S.ch[pos + i - 1]; // 注意数组下标从0开始，但子串的位置从1开始，所以减1。
    }
    Sub->length = len; // 设置子串长度为len。
}

// 串联接。用T返回由S1和S2联接而成的新串。
void Concat(SString *T, SString S1, SString S2)
{
    int len1 = S1.length, len2 = S2.length; // 取两个串的长度总和（不包括结束符'\0'）
    if (len1 + len2 <MAXLEN)
    { // 确保总长度不超过最大值，并进行边界检查和越界处理。注意这里需要为新串添加结束符'\0'。
        for (int i = 0; i < len1 + len2; i++) 
        { // 把新串的字符复制到T中（不包括结束符'\0'）
            if (i < len1)
                T->ch[i] = S1.ch[i]; // 先复制S1的字符
            else
                T->ch[i] = S2.ch[i - len1]; // 然后复制S2的字符
        }
        T->ch[len1 + len2] = '\0'; // 在新串的末尾添加结束符'\0'
    }
    T->length = len1 + len2; // 设置新串的长度为两个串的长度总和。
}

// 定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
int Index(SString S, SString T)
{
    int len1 = S.length, len2 = T.length;
    if (len2 == 0)
        return 0; // 子串为空串，返回0
    if (len1 < len2)
        return -1; // 主串长度小于子串长度，返回-1
    
    //使用strncmp函数比较从当前位置i开始的子串（长度为len2）与子串T
    for (int i = 0; i <= len1 - len2; i++)
    { // 从主串的开始位置到结束位置依次比较
        if (strncmp(S.ch + i, T.ch, len2) == 0)
            return i+1; // 若找到相同的子串，返回子串在主串中的位置
    }

    return -1; // 若未找到相同的子串，返回-1
}

// 清空操作。将S清为空串。
void Clearstring(SString *S)
{
    S->length = 0; // 将串的长度置为0
}

// 销毁串。将串S销毁。
void Destroystring(SString *S)
{   //注意这里只是做了标记，真正的内存并没有被释放。如果要释放内存，需要使用其他方法。
    S->length = -1; // 将串的长度置为-1，表示该串已销毁。
}

void printf(SString S){
        for(int i=0;i<S.length;i++){
        cout<<S.ch[i];
    }
    cout<<endl;
    //cout<<endl<<S.length<<endl;
}
int main()

{
    SString S1,S2,sub,T1;
   char a[]="ktuh2agj";
   char b[]="2agj";
   char c[]="syw";
    //赋值
    //void StrAssign(SString *T, char* chars)
    StrAssign (&S1,a);//这里S1传递的是引用
    StrAssign (&sub,c);
    StrAssign (&T1,b);

    cout<<"主串是： ";
    printf(S1);

    //复制
     Strcopy(&S2,S1);
     cout<<"复制的串的是： ";
    printf(S2);

    //判空
    cout<<"是否空： "<<StrEmpty(S2)<<endl;

    //清空
    Clearstring(&S2);
    cout<<"Clearstring后是否空: "<<StrEmpty(S2)<<endl;

    //求字串
    Substring(&sub,S1,1,3);
    cout<<"前三位子串是： ";
    printf(sub);

    //比大小
    cout<<"主串和字串比较： "<<StrCompare(S1,sub)<<endl;

    //串连接
    SString T;
    Concat(&T,S1,sub);
     cout<<"连接主串和前三位子串后的字符串是： ";

    printf(T);
    //定位
    cout<<"2agj的位置是"<<Index(S1,T1)<<endl;
    

    return 0;
}

在这里插入图片描述

注意细节
1.下面是两种运算符的区别

在这里插入图片描述

2.下面是值传递、指针传递和引用传递
#include <iostream>
 
void changeValue(int num) {
    num = 5;
}

void changeValue1(int* numPtr) {
    *numPtr = 5;
}

void changeValue2(int& numRef) {
    numRef = 5;
}


int main() {
    int num = 10;
    changeValue(num);
    std::cout << "值传递不变： "<<num << std::endl; // 输出结果为10，原始值未被修改
    
    int num1 = 10;
    changeValue1(&num1);
    std::cout <<"指针传递可改变： "<<num1 << std::endl; // 输出结果为5，原始值被修改

    int num2 = 10;
    changeValue2(num2);
    std::cout <<"引用传递可改变： " <<num2 << std::endl; // 输出结果为5，原始值被修改

    
    return 0;
}
串的模式匹配
BF算法

在这里插入图片描述

#include<iostream>
using namespace std;
#define MAXLEN 255 // 预定义最大串长为255
// 定长数组实现（定长顺序存储 ）
typedef struct
{
    char ch[MAXLEN]; // 每个分量存储一个字符
    int length;      // 串的实际长度
} String;

//这里直接使用string和length()函数
int Index_BF(string s, string t) {  
    int i = 0, j = 0;  
    int lens = s.length(); 
    int lent = t.length();  
    while (i <= lens - lent) { //这里比较次数为lens-lent+1次 
        j = 0; // 每次从头开始比较子串t 

        while (j < lent && s[i + j] == t[j]) {  //逐个比较s串和t串
            j++;  
        }  
        if (j == lent) {  
            return i; // 找到匹配，返回起始索引下标  
        }  

        i++; // 如果不匹配，i向前移动一位  
    }  
    return -1; // 未找到匹配  
}

int main(){
    string a="ktuh2agj";
    string b="2agj";    
    cout<<Index_BF(a,b)<<endl;//返回的是索引下标
    return 0;
}
KMP算法

在这里插入图片描述

#include<iostream>
#include<cstring>

using namespace std;
#define MAXLEN 255 // 预定义最大串长为255
// 定长数组实现（定长顺序存储 ）
typedef struct
{
    char ch[MAXLEN]; // 每个分量存储一个字符
    int length;      // 串的实际长度
} SString;

//求模式串T的next数组:想一想自己怎么样实现这个求得过程？
//这里是指针传递
void get_next(SString T,int next[]){
    int i=1,j=0;
    next[1]=0;
    while (i<T.length){//第一个的next值已经确定
        if(j==0||T.ch[i]==T.ch[j])
        {
            ++i;++j;
            next[i]=j;
        }
        else{
            j=next[j];
        }
        
    }
}

//KMP算法是三个人提出的故而叫做KMP算法
int Index_KMP(SString S, SString T, int next[])
{
    int i = 1, j = 1;
    while (i <= S.length && j <= T.length)  //i永远不递减
    {
        if (j == 0 || S.ch[i] == T.ch[j]) //字符匹配成功,指针后移
        {
            ++i;
            ++j;
        }
        else  //字符匹配失败, 根据next跳过前面的一些字符
            j = next[j];
    }
    if (j > T.length)  // 匹配成功
        return i - T.length;
    else
        return 0;
}
void kmp(){
    SString S, T;  
    int next[MAXLEN];  
  
    // 初始化主串S  
    strcpy(S.ch, "ABABDABACDABABCABAB");  
    S.length = strlen(S.ch);  
  
    // 初始化模式串T  
    strcpy(T.ch, "ABABCABAB");  
    T.length = strlen(T.ch);  
  
    // 计算模式串T的next数组  
    get_next(T, next);  
  
    // 打印next数组（可选）  
    printf("Next array: ");  
    for (int i = 1; i <= T.length; i++) {  
        printf("%d ", next[i]);  
    }  
    printf("\n");  
  
    // 使用KMP算法查找模式串T在主串S中的位置  
    int index = Index_KMP(S, T, next);  
    if (index != 0) {  
        printf("Pattern found at index: %d\n", index);  
    } else {  
        printf("Pattern not found.\n");  
    }      
}

int main(){
    //KMP
    kmp();
    
    return 0;
}
澄澈蓝
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——串
FREEDOM’s blog
07-08 4699
串的定义、基本操作、存储结构、模式匹配（朴素模式匹配算法、KMP算法）
数据结构之串的总结
懒惰的小黑的博客
09-01 7730
串的基本概念 串的定义 串是由0个或多个字符组成的有限序列，又叫字符串。 空串 长度为0的串，不包含任何字符。 空白串 由一个或多个空白字符组成的串。 子串 串的任意个连续字符组成的串子序列。子串的位置是以子串在主串中首次出现时的第一个字符在主串中的位置来表示。 主串 包含子串的串相应的叫主串。 串的比较 串的比较是通过组成串中的字符之间的编码来进行的，而字符的编码指的是字符在字符集中的序号。通过两串字符的比较，若不等，则返回第一个不相等的字符的数值差。 例： compareTo（s
数据结构之串（完整代码）
起个名字真难的博客
07-29 2883
数据结构之串定义串的基本操作KMP算法实现（串的唯一重点） 定义串的基本操作 //这儿的下标默认是1开始 #include<iostream> #include<cstring> #include<stdlib.h> using namespace std; #define MAXLEN 255 typedef struct{ char ch[MAXLEN]; int length; }SString;//定长顺序存储表示 typedef st
数据结构之串和数组基本知识和问题
sereasuesue的博客
05-13 1972
★★ 串 1. 串（又称字符串）是一种特殊的线性表，它的每个结点仅由一个字符组成。 从数据结构的观点来说，串是一种特殊的线性表;但就数据类型而言，串不是线性表。 **串（ String ）是零个或多个字符组成的有限序列。 一般记为s= “ a0a1a2...an-1 ”(n≥0，下标从0开始)，其中s是串的名，用双引号括起来的字符序列是串的值。 将串值括起来的单引号本身不属于串 , 它的作用是避免串与常数或与标识符 混淆。 2. 长度为零的串称为空串（ Empty String ），它不包含..
数据结构之串的基本操作
热门推荐
qq_36964872的博客
05-30 2万+
1.串的实现相比较而言简单一些，但个人觉得有一些需要注意的地方，以下一 一列举：（1）串基本术语：空串：空串指长度为0的串，其不包含任何字符；空格串：不同于空串，它是由一个或多个空格构成的串。虽然是空格，但在计算长度时要把空格的个数算在内；串比较：串的大小比较时以字符的ASCII码值作为依据。（2）串基本操作：赋值操作、连接操作、求串长、窜的比较和求子串。（3）串的存储结构：顺序存储和链式存储。其...
数据结构-串
weixin_46441425的博客
04-26 4364
4.1 数据结构——串
weixin_45523296的博客
10-14 4307
串的定义、串的抽象数据类型、串的顺序存储结构和串的链式存储结构、串的模式匹配（BF算法、KMP算法）
《数据结构》之求子串
weixin_45217677的博客
04-24 1万+
一.串（string) 是有零个或n个字符组成的有限序列，如： S=‘advj4_ ekf oskdl’ 其中S为串名，单引号引起来的是串的值，可以由字母，数字或其他字符串组成，字符的个数称为串的长度，长度为0的串为空串，字符在串中的序号（从1开始）称为字符的位置，串中任意个连续的字符组成的序列称为子串，包含子串的串称为主串，子串中第一个字符在主串中的位置称为子串的位置，下面讲述如何从主串中...
数据结构之串的定长顺序存储
偶然i的博客
03-13 3037
技术交流qq：1032492413 技术交流VX:Chamfion
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 ...
javascript数据结构之串的概念与用法分析
10-20
在JavaScript中，串（String）是一种重要的数据结构，它由零个或多个字符组成，用于存储文本信息。在本文中，我们将深入探讨JavaScript中的串概念、功能以及如何使用它们进行遍历、比较和查找。 首先，理解串的基本...
数据结构之串—关键词搜索
11-15
本文将深入探讨“数据结构之串—关键词搜索”，并结合win32程序设计，阐述串（字符串）在数据处理和文件操作中的重要作用。 首先，我们要了解什么是“串”。在计算机科学中，串是字符的有限序列，通常由字母、数字...
[数据结构] 基于交换的排序 冒泡排序&&快速排序
水墨不写bug
07-06 908
让右下标先走，向左寻找比key小的值，找到后停下来：停下来后：左下标再向右寻找比key大的值，找到后停下来：此时，交换两个下标对应的值：接下来继续执行上述步骤（R先走），我展示关键步骤：两下标找到要求目标并交换：直到遇到特殊情况：两下标相遇这时停止停止循环，将最左侧元素与相遇处的元素交换位置：即可完成一次二分。
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 993
插入排序&&希尔排序 实现原理
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
架构筑梦的Cherry Yang的博客
07-06 944
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
Redis教程(二十三)：Redis的底层数据结构
最新发布
十三月的博客
07-09 91
Redis是一种高性能的key-value数据库，广泛用于缓存、消息队列、应用程序会话管理等领域。它之所以能提供高效的数据操作性能，很大程度上归功于其底层使用了多种优化过的数据结构来存储数据。
数据结构第07节：队列
hummhumm的专栏
07-04 562
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
6、Redis系统-数据结构-03-压缩列表
qq_29434541的博客
07-07 1057
由于压缩列表需要进行空间扩展操作，这就需要重新分配内存，因此连锁更新一旦发生，会导致压缩列表占用的内存空间多次重新分配，直接影响到压缩列表的访问性能。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。因此，虽然压缩列表紧凑型的内存布局能节省内存开销，但是如果保存的元素数量增加，或元素变大，会导致内存重新分配，最糟糕的是会引发「连锁更新」的问题。而当新插入的元素较大时，可能会导致后续元素的。
python 数据结构之串的链式存储结构
05-09
Python中的链式存储结构是一种常见的数据结构，其中串是一种特殊的链表。在链表中，每个节点都包含一个数据元素和一个指向下一个节点的指针。在串的链式存储结构中，每个节点包含一个字符和一个指向下一个节点的指针。 具体来说，串的链式存储结构包含一个头指针和一个尾指针。头指针指向链表中第一个节点，尾指针指向最后一个节点。每个节点包含一个字符和一个指向下一个节点的指针。可以通过头指针和尾指针来遍历整个链表。 在Python中，可以使用类来实现串的链式存储结构。例如，可以定义一个名为Node的类来表示链表中的节点，并将每个节点连接起来以创建链表。同时，还可以定义一个名为LinkedList的类来表示整个链表，并提供常见的方法，如添加节点、删除节点和搜索节点等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值