数据结构--串

最新推荐文章于 2023-09-15 06:00:00 发布
最新推荐文章于 2023-09-15 06:00:00 发布
阅读量341 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45981481/article/details/120065476
版权

目录

一、串的基本操作

1 . 静态数组实现(定长顺序存储)

1-1 代码运行结果​

 2 . 动态数组实现(堆分配存储)

2-1 代码运行结果​

二、串的匹配模式

1 . 简单的匹配算法

1-1 代码运行结果​

2 . 改进的模式匹配算法——KMP算法

2-1 代码运行结果​

3 . KMP算法的进一步优化

3-1 代码运行结果​

一、串的基本操作

1 . 静态数组实现(定长顺序存储)

#include <iostream>
#include <string.h>

using namespace std;

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

//初始化
bool InitString(SString &S) {
    S.length = 0;
    return true;
}
//赋值操作 把串T赋值为 chars
bool StrAssign(SString &T, const char *chars) {
    if(strlen(chars) > MAXLEN) {
        return false;
    }
    for (int i = 1; i <= strlen(chars); i++) {
        T.ch[i] = chars[i - 1];
        T.length++;
    }
    return true;
}
//复制操作 由串S复制得到T
bool StrCopy(SString &T, SString S) {
    for(int i = 1; i <= S.length; i++) {
        T.ch[i] = S.ch[i];
        T.length++;
    }
    return true;
}
//判空操作 空返回true 非空则false
bool StrEmpty(SString S) {
    if(S.length == 0) {
        return true;
    }
    return false;
}
//若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;
}
//返回串长
int StrLength(SString S) {
    return S.length;
}
//求子串 用sub返回串s的第pos个位置开始的长度为len的串
bool SubString(SString &Sub, SString S, int pos, int len) {
    if(pos + len - 1 > S.length || pos < 1 || pos > S.length) { //字串范围越界 下标不合法
        return false;
    }
    for (int i = pos; i < pos + len; i++) {
        Sub.ch[i - pos + 1] = S.ch[i];
    }
    Sub.length = len;
    return true;
}
//字符串拼接 用T返回由S1和S2连接的新串
bool Concat(SString &T, SString S1, SString S2) {
    if(S1.length + S2.length > MAXLEN) { //字符串拼接会被截断
        for (int i = 1; i <= S1.length ; i++) {
            T.ch[i] = S1.ch[i];
        }
        for (int i = 1; i <= MAXLEN - S1.length ; i++) {
            T.ch[S1.length  + i] = S2.ch[i];
        }
        T.length  = MAXLEN;
        return false;
    } else { //字符串拼接不会被截断
        for (int i = 1; i <= S1.length ; i++) {
            T.ch[i] = S1.ch[i];
        }
        for (int i = 1; i <= S2.length ; i++) {
            T.ch[S1.length  + i] = S2.ch[i];
        }
        T.length  = S1.length + S2.length ;
        return true;
    }
}
//返回串T在S中第一次出现的位置 不存在返回0
int Index(SString S, SString T) {
    int i = 1, n = StrLength(S), m = StrLength(T);
    SString sub;
    while(i <= n - m + 1) {
        SubString(sub, S, i, m);
        if(StrCompare(sub, T) != 0) {
            ++i;
        } else {
            return i;//返回字串在主串中的位置
        }
    }
    return 0;//S 中不存在与 T相等的字串
}
//清空操作
bool ClearString(SString &S) {
    S.length = 0;
    return true;
}
//打印串
bool showString(SString S) {
    if(StrEmpty(S)) {
        return false;
    }
    for (int i = 1; i <= S.length; i++) {
        cout << S.ch[i];
    }
    cout << endl;
    return true;
}
void test() {
    SString S1;
    InitString(S1);
    if(StrEmpty(S1)) {
        cout << "S1 Is Empty!" << endl;
    } else {
        cout << "S1 Isn't Empty!" << endl;
    }
    StrAssign(S1, "SString");
    showString(S1);
    SString S2;
    InitString(S2);
    StrCopy(S2, S1);
    showString(S2);
    cout << "StrCompare(S1, S2): " << StrCompare(S1, S2) << endl; // =0
    cout << "StrLength(S1): " << StrLength(S1) << endl;
    cout << "StrLength(S2): " << StrLength(S2) << endl;
    //求字串，用 Sub返回 串S 的第 pos 个位置开始的长度为 len 的串
    SString Sub;
    InitString(Sub);
    SubString(Sub, S1, 2, 4);
    showString(Sub);
    SString T;
    InitString(T);
    Concat(T, S1, S2);
    showString(T);
//    //返回 串Sub 在 S1 中第一次出现的位置，不存在返回0
    cout << "Index(S1, Sub):" << Index(S1, Sub) << endl;
    ClearString(S1);
    cout << "StrLength(S1):" << StrLength(S1) << endl;
}
int main() {
    test();
    return 0;
}

1-1 代码运行结果

 2 . 动态数组实现(堆分配存储)

#include <iostream>
#include <string.h>

using namespace std;

#define MAXLEN 10//预定义最大串长 10
typedef struct {
    //动态数组实现(堆分配存储)
    char *ch;//按串长分配存储区 ch指向串的基地址
    int length;//串的长度
    int maxSize;
} HString;

typedef struct StringNode { //存储密度低 每个字符 1B 每个指针 4B(以32位系统为例)
    //串的链式存储
    char ch;//每个结点存 1 个字符
    struct StringNode *next;
} StringNode, *String;
//typedef struct StringNode { //存储密度提高
//    //串的链式存储(推荐)
//    //如果结点存不满 可以用特殊字符(如 '\0')填充
//    char ch[4];//每个结点存 多 个字符
//    struct StringNode *next;
//} StringNode, *String;

//初始化
bool InitString(HString &S) {
    S.ch = (char *)malloc(MAXLEN * sizeof(char));
    S.length = 0;
    S.maxSize = MAXLEN;
}
//增加串 长度
bool increaseStringSize(HString &S, int len) {
    char *p = S.ch;
    S.ch = (char *)malloc((S.maxSize + len) * sizeof(char));
    if(!S.ch) { //申请空间失败
        return false;
    }
    for (int i = 1; i <= S.length; i++) {
        S.ch[i] = p[i];
    }
    S.maxSize += len;
    free(p);
}
//赋值操作 把串T赋值为 chars
bool StrAssign(HString &T, const char *chars) {
    if(strlen(chars) > T.maxSize) {
        increaseStringSize(T, strlen(chars) - T.maxSize);
    }
    for (int i = 1; i <= strlen(chars); i++) {
        T.ch[i] = chars[i - 1];
        T.length++;
    }
    return true;
}
//复制操作 由串S复制得到T
bool StrCopy(HString &T, HString S) {
    if(T.length < S.length) {
        increaseStringSize(T, S.length - T.length);
    }
    for(int i = 1; i <= S.length; i++) {
        T.ch[i] = S.ch[i];
        T.length++;
    }
    return true;
}
//判空操作 空返回true 非空则false
bool StrEmpty(HString S) {
    if(S.length == 0) {
        return true;
    }
    return false;
}
//若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;
}
//返回串长
int StrLength(HString S) {
    return S.length;
}
//求子串 用sub返回串s的第pos个位置开始的长度为len的串
bool SubString(HString &Sub, HString S, int pos, int len) {
    if(pos + len - 1 > S.length || pos < 1 || pos > S.length) { //字串范围越界 下标不合法
        return false;
    }
    for (int i = pos; i < pos + len; i++) {
        Sub.ch[i - pos + 1] = S.ch[i];
    }
    Sub.length = len;
    return true;
}
//字符串拼接 用T返回由S1和S2连接的新串
bool Concat(HString &T, HString S1, HString S2) {
    if(S1.length + S2.length > T.maxSize) { //字符串拼接会被截断 需要拓展容量
        increaseStringSize(T, S1.length + S2.length - T.maxSize);
    }
    for (int i = 1; i <= S1.length ; i++) {
        T.ch[i] = S1.ch[i];
    }
    for (int i = 1; i <= S2.length ; i++) {
        T.ch[S1.length  + i] = S2.ch[i];
    }
    T.length  = S1.length + S2.length ;
    return true;
}
//返回串T在S中第一次出现的位置 不存在返回0
int Index(HString S, HString T) {
    int i = 1, n = StrLength(S), m = StrLength(T);
    HString sub;
    while(i <= n - m + 1) {
        SubString(sub, S, i, m);
        if(StrCompare(sub, T) != 0) {
            ++i;
        } else {
            return i;//返回字串在主串中的位置
        }
    }
    return 0;//S 中不存在与 T相等的字串
}
//清空操作
bool ClearString(HString &S) {
    S.length = 0;
    return true;
}
//销毁串
bool DestoryString(HString &S) {
    S.length = 0;
    if(!S.ch) {
        free(S.ch);
    }
    return true;
}
//打印串
bool showString(HString S) {
    if(StrEmpty(S)) {
        return false;
    }
    for (int i = 1; i <= S.length; i++) {
        cout << S.ch[i];
    }
    cout << endl;
    return true;
}
void test() {
    HString S1;
    InitString(S1);
    if(StrEmpty(S1)) {
        cout << "S1 Is Empty!" << endl;
    } else {
        cout << "S1 Isn't Empty!" << endl;
    }
    StrAssign(S1, "googooglegoogoogle");
    showString(S1);
    HString S2;
    InitString(S2);
    StrCopy(S2, S1);
    showString(S2);
    cout << "StrCompare(S1, S2): " << StrCompare(S1, S2) << endl; // =0
    cout << "StrLength(S1): " << StrLength(S1) << endl;
    cout << "StrLength(S2): " << StrLength(S2) << endl;
    //求字串，用 Sub返回 串S 的第 pos 个位置开始的长度为 len 的串
    HString Sub;
    InitString(Sub);
    SubString(Sub, S1, 13, 6);
    showString(Sub);
    HString T;
    InitString(T);
    Concat(T, S1, S2);
    showString(T);
    cout << "StrLength(T):" << StrLength(T) << endl;
    //    //返回 串Sub 在 S1 中第一次出现的位置，不存在返回0
    cout << "Index(S1, Sub):" << Index(S1, Sub) << endl;
    ClearString(S1);
    cout << "StrLength(S1):" << StrLength(S1) << endl;
    DestoryString(T);
}
int main() {
    test();
    return 0;
}

2-1 代码运行结果

二、串的匹配模式

1 . 简单的匹配算法

//简单的模式匹配算法
int Index_01(HString S, HString T) {
    //分别用计数指针 i j 指示主串 S 和模式串 T当前正待比较字符的位置
    int i = 1, j = 1;
    while(i <= S.length && j <= T.length) {
        if(S.ch[i] == T.ch[j]) { //继续比较字符
            ++i;
            ++j;
        } else { //指针后退重新匹配
            i = i - j + 2;
            j = 1;
        }
    }
    if(j > T.length) {
        return i - T.length;
    } else {
        return 0;
    }
}
void test02() {
    HString S;
    InitString(S);
    StrAssign(S, "sdbdnhfvfnjgoogooglegoogoogle");
    showString(S);
    HString T;
    InitString(T);
    StrAssign(T, "google");
    showString(T);
    cout << Index_01(S, T) << endl;
}

1-1 代码运行结果

2 . 改进的模式匹配算法——KMP算法

//改进的的模式匹配算法--(KMP算法)

//获得next值
void getNext(HString T, int next[]) {
    int i = 1, j = 0;
    next[1] = 0;
    while (i < T.length) {
        if(j == 0 || T.ch[i] == T.ch[j]) {
            ++i;
            ++j;
            next[i] = j; //若pi=pj 则next[j+1]=next[j]+1;
        } else {
            j = next[j];//否则令j=next[j] 循环继续
        }
    }
}
//KMP算法
int Index_KMP(HString S, HString T, int next[]) {
    //分别用计数指针 i j 指示主串 S 和模式串 T当前正待比较字符的位置
    int i = 1, j = 1;
    while(i <= S.length && j <= T.length) {
        if(j == 0 || S.ch[i] == T.ch[j]) { //继续比较后继字符
            ++i;
            ++j;
        } else { //模式串向右移动
            j = next[j];
        }
    }
    if(j > T.length) {
        return i - T.length;//匹配成功
    } else {
        return 0;
    }
}
void test03() {
    HString S;
    InitString(S);
    StrAssign(S, "sdbdnhfvfnjgoogooglegoogoogle");
    showString(S);
    HString T;
    InitString(T);
    StrAssign(T, "google");
    showString(T);
    int next[10];
    getNext(T, next);
    cout << Index_KMP(S, T, next) << endl;
}

2-1 代码运行结果

3 . KMP算法的进一步优化

//KMP算法的进一步优化
void getNextVal(HString T, int nextval[]) {
    int i = 1, j = 0;
    nextval[1] = 0;
    while (i < T.length) {
        if(j == 0 || T.ch[i] == T.ch[j]) {
            ++i;
            ++j;
            if(T.ch[i] != T.ch[j]) {
                nextval[i] = j;
            } else {
                nextval[i] = nextval[j];
            }
        } else {
            j = nextval[j];
        }
    }
}
//KMP算法
int Index_KMP(HString S, HString T, int next[]) {
    //分别用计数指针 i j 指示主串 S 和模式串 T当前正待比较字符的位置
    int i = 1, j = 1;
    while(i <= S.length && j <= T.length) {
        if(j == 0 || S.ch[i] == T.ch[j]) { //继续比较后继字符
            ++i;
            ++j;
        } else { //模式串向右移动
            j = next[j];
        }
    }
    if(j > T.length) {
        return i - T.length;//匹配成功
    } else {
        return 0;
    }
}
void test04() {
    HString S;
    InitString(S);
    StrAssign(S, "sdbdnhfvfnjgoogooglegoogoogle");
    showString(S);
    HString T;
    InitString(T);
    StrAssign(T, "google");
    showString(T);
    int nextval[10];
    getNextVal(T, nextval);
    cout << Index_KMP(S, T, nextval) << endl;
}

3-1 代码运行结果

我这么好看
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构(C语言版)----------串的堆分配C语言实现
weixin_43482612的博客
11-07 610
实现代码 #include <cstdio>//printf();scanf() #include <cstdlib>//exit();malloc() #include<string.h> #include<iostream> using namespace std; //函数结束状态代码 #define OVERFLOW -1 #define...
堆串的C语言实现（数据结构）
HiimYYK的博客
01-12 275
堆串的C语言实现，参考书目《数据结构》严蔚敏版。 包含了.h头文件和.c实现
串的静态数组实现方式(C++版)
weixin_42295110的博客
07-14 763
串的基本操作有： StrAssign(&T,chars):赋值操作,把串T赋值为chars StrCopy(&T,S):复制操作,由串S复制得到串T StrEmpty(S):字符串的判空操作,若S为空串则返回True,否则返回false StrLength(S):求串长,返回串S的元素个数。 ClearString(&S):清空操作,将S清为空串。 DestoryString(&S):销毁串,将串S销毁(回收存储...
数据结构笔记（十三）-- 串的堆分配存储表示
m0_43609475的博客
06-13 4627
串的堆分配存储表示 一、堆分配存储概述 堆分配内存仍是一组地址连续的存储单元来存放串值字符序列，但是存储空间实在程序执行过程中动态分配而得。在C语言中，存在一个称为“堆”的自由存储区，并由C语言的动态分配函数malloc()和free()来管理。利用函数malloc()为每个新产生的串分配一块实际串长所需的存储空间，若分配成功，则返回一个指向起始地址的指针，作为串的基址，同时为了方便以后的处理，约定串长也作为存储结构的一部分。 二、串的堆分配存储结构 三、串的操作 //1、初始化(产生空串)字符串S v
【学数据结构】-----串（顺序串、堆串、块链串）（7000字总结+代码+图）
登登的博客 是温馨的小屋。
06-10 3464
计算机处理的对象分为数值处理和非数值处理，字符串是最基本的非数值数据。 字符串处理在语言编译、信息检索、文字编辑等领域有着广泛的应用。 数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。...
数据结构--串的实验报告
09-27
数据结构中的“串”是指由一个或多个字符组成的序列，它是字符的有限序列。在这个实验报告中，我们主要探讨了串的顺序存储结构和链式存储结构，以及如何实现串的一些基本操作，如连接、插入、删除、显示、求串长度和...
数据结构-串、数组和广义表-PPT
02-04
"数据结构-串、数组和广义表-PPT" 本节，我们将详细介绍数据结构中串、数组和广义表的定义、特点和操作。 串的定义 串是一种特殊的线性表，其特殊性体现在数据元素是一个字符，也就是说，串是一种内容受限的...
漫话数据结构-串上的操作.pptx
11-03
在众多的数据结构中，"串"是一个基本且重要的元素，特别是在处理文本信息时。在本节中，我们将深入探讨串的存储结构以及其上的一些基本操作。 串，也被称为字符串，在许多编程语言中被广泛使用，它是字符的有序集合...
漫话数据结构-串的存储及操作.pptx
11-03
【漫话数据结构-串的存储及操作】深入解析 数据结构是计算机科学中的核心概念，它涉及到如何高效地组织和存储数据以便于执行各种操作。在这个话题中，我们将聚焦于“串”的存储和操作，这是数据结构中的一个重要...
数据结构---串的基本操作完整代码（C语言）
05-05
其中，“串”（String）作为一种基本的数据结构，被广泛应用于文本处理、字符串搜索等领域。本篇文章将深入探讨串的基本操作，并提供完整的C语言实现代码。 串是由字符组成的序列，字符可以是任何ASCII码或Unicode...
【数据结构 严蔚敏版】 串的堆分配存储 基本操作
热门推荐
Friday
12-22 1万+
串的堆分配存储表示的特点是，仍以一组地址连续的存储单元存放串值字符序列，但它们的存储空间是在程序执行过程中动态分配的。使用动态分配函数malloc()和函数free()来管理存储空间的大小。 串的堆分配存储方法具有顺序存储的特点，又弥补了定长存储的大小限制，多以多被采用。 //文件名：串操作----堆分配存储实现 //描述：这个存储的特点是，仍以一组地址连续的存储单元存放串值字符序列，但是存储空...
【数据结构】串的定义；存储结构；基本操作的实现
最新发布
小人物，大梦想！
09-15 1311
串的定义；串的存储结构（顺序存储；链式存储；串的堆分配存储表示）；串的基本操作（求子串；比较操作；定位操作）；C语言实现串的基本操作
6. 字符串 - 串存储结构及KMP算法
园长QwQ
03-19 636
文章目录6. 字符串 - 串存储结构6.1 字符串基本概念6.2 串存储结构实现方法6.2.1 定长顺序存储6.2.3 堆分配存储6.2.3 块链存储6.3 串的模式匹配算法6.3.1 BF算法 - 普通模式匹配算法6.3.2 KMP算法 - 快速模式匹配算法 6. 字符串 - 串存储结构 6.1 字符串基本概念 串结构是用于存储字符类型的数据的线性存储结构 根据串中存储字符的数量及特点，对一些特殊的串进行了命名和分类： 空串：存储 0 个字符的串，例如 S = ""（双引号紧挨着） 空格串：只包含空
数据结构：串：用顺序表实现串的一些基础操作
id_IamYang的博客
05-04 77
【运行代码】数据结构：串：用顺序表实现串的一些基础操作。
串的复习自用
weixin_50334311的博客
03-28 63
就是将串S中的元素（从字串起始位置开始的）赋值给子串中的元素，让字串从0开始，所以从让i与pos相减。） pos+len-1可以在最大极限的情况下会遍历出整个字串pos+len会漏一些情况。方案四——最终使用方案：**ch[0]废弃不用，声明int型变量length来存放串的长度（方案一与方案二的结合）方案三：没有length变量，以字符’\0’表示结尾（对应ASCII码的0）；方案一：用一个额外的变量length来存放串的长度（保留ch[0]）；1.串中元素的位序是从1开始不是从0开始，和。
串的基本操作
m0_51602066的博客
07-20 103
代码】串的基本操作。
【数据结构】第四章 串（1）定义，基本操作，存储方式，静态数组存储的代码实现（C++）
weixin_37706349的博客
06-04 940
目录4.1-1 串的定义和基本操作知识总览：​编辑一、串的定义二、串和线性表的比较三、串的基本操作 四、字符集编码 五、拓展：乱码问题 总结：4.1_2 串的存储结构知识总览： 一、串的顺序存储二、串的链式存储 三、基本操作的实现总结：数据结构三要素：逻辑结构、数据的运算、存储结构（物理结构）。存储结构不同，运算的实现方式也不同。串，即字符串（String）是由零个或多个字符组成的有限序列。一般记为其中，S是串名，单引号括起来的字符串序列是串的值；可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n
串的定长顺序存储结构
烽火前秦路
04-02 1602
串的定长顺序存储结构

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

我这么好看

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值