c语言数据结构-串

最新推荐文章于 2024-04-30 02:01:57 发布

小周不想卷

最新推荐文章于 2024-04-30 02:01:57 发布

阅读量1k

点赞数 7

分类专栏：数据结构与算法文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/weixin_73295475/article/details/128693012

版权

数据结构与算法专栏收录该内容

18 篇文章 5 订阅

订阅专栏

本文介绍了串的概念，包括顺序存储结构和链式存储结构，分别提供了为串赋值的示例代码。同时，讨论了串的模式匹配算法，如BF算法和KMP算法，解释了它们的工作原理和应用场景。

摘要由CSDN通过智能技术生成

(创作不易，感谢有你，你的支持，就是我前行的最大动力，如果看完对你有帮助，请留下您的足迹）

初识串：

定义：
零个或多个字符组成的有限序列。

当串长n=0时，又称为空串

串还有其他的基本概念，如下所示：

主串： a='BEI JING'

子串： b='BEI',

c='JING'

字符位置：从1开始
串相等： d='BEI JING'
空格串： e=' '

串的顺序储存结构：

串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。

注意：
“ \ 0” 用来表示串值的终结，计算串值长度时不计。

/** 串的堆式顺序存储结构（Heap） */
typedef struct 
{
    char* ch;      //如果是非空串，那么就按照指定长度分配内存，否则ch就指向NULL
    int length;     //串的当前长度
}HString;

/** 初始化堆字符串 */
void InitString_HeapString(HString* str)
{
    str->ch = NULL;
    str->length = 0;
}

给顺序串赋值：

/** 为串str赋值，值为字符串常量chars */
int StrAssign_HeapString(HString* str, char* chars)
{
    int len = strlen(chars);
    if (!len) 
    {
        return 0;
    }
    InitString_HeapString(str);
    str->ch = (char*)malloc(len * sizeof(char));
    if (!str->ch)
    {
        exit(-2);
    }
    for (int i = 0; i < len; i++) 
    {
        str->ch[i] = chars[i];
    }
    str->length = len;
    return 1;
}

串的链式储存结构：

优点：操作方便
缺点：存储密度较低（存储密度 = 串值所占的存储位/实际分配的存储位）

如图所示，链串由块数据和指针构成，而块数据的大小可以自定义

#define BLOCK_SIZE 80   //定义块的大小，可自行修改
/** 块的定义 */
typedef struct block
{
    char ch[BLOCK_SIZE];    //块数据
    struct block* next;    //指向下一个块的指针
}Block;

/** 串的链式存储结构 */
typedef struct
{
    Block* head;   //串的头指针
    Block* tail;   //串的尾指针
    int length;     //串的当前长度
}LString;   //LinkedString的缩写

/** 初始化链串 */
void InitString_LinkedString(LString* str)
{
    str->head = NULL;
    str->tail = NULL;
    str->length = 0;
}

给链串赋值：

/** 为链串str赋值，值为字符串常量chars */
int StrAssign_LinkedString(LString* str, char* chars)
{
    int len = strlen(chars);
    if (!len)
        return 0;
    InitString_LinkedString(str);
    //计算出块的总数：假设长度96，那么就需要有1个块零16个字符
    int block_count = (len + 1) / BLOCK_SIZE; //len+1是因为最后要赋值'\0'表示字符串的结束
    //余下的字符总数
    int surplus_count = (len + 1) % BLOCK_SIZE;
    if (surplus_count > 0) 
    {
        block_count++;  //如果有余下的字符，就需要多一个块来存放
    }
    Block* block;
    for (int i = 1; i <= block_count; i++) 
    {
        block = (Block*)malloc(sizeof(Block));
        if (!block) exit(-2);
        block->next = NULL;
        //在每个块中复制对应的字符
        int count = 0;
        for (; count < BLOCK_SIZE && (count + (i - 1) * BLOCK_SIZE < len); count++)
        {
            //count为当前块要复制的字符个数
            //(i - 1) * BLOCK_SIZE 为 第i个块之前的字符总数
            block->ch[count] = chars[count + (i - 1) * BLOCK_SIZE]; //逐个字符复制
        }
        if (i == block_count) 
        {
            //最后一个块
            block->ch[count] = '\0';
        }
        if (i == 1) 
        {
            //如果是第一个块，链串首尾指针都指向这个块
            str->head = str->tail = block;
        }
        else
        {
            //如果不是第一个块，就需要连接这个块
            str->tail->next = block;    //当前链尾的next指向block
            str->tail = block;          //链尾再修改为block - 链表的常用操作
        }
    }
    str->length = len;
    return 1;
}

串的模式匹配算法：

算法目的：

确定主串中所含字串第一次出现的位置
实现串的定位操作——Index(S,T,pos)函数

算法种类：

BF算法：

又称古典的、经典的、朴素的、穷举的

BF算法思路：主串和子串（又称模式串）都从a开始比较，若两者相同，则i++，j++，两者共同向后比较，当到达第三个元素位置时，两者不相同，此时主串i退回到b的位置（i指针回溯），j则退回到a的位置，重新比较，直到两者比较的元素均相同

/** 串的堆式顺序存储结构（Heap） */
typedef struct
{
    char* ch;      //如果是非空串，那么就按照指定长度分配内存，否则ch就指向NULL
    int length;     //串的当前长度
}HString;

/** 初始化堆字符串 */
void InitString_HeapString(HString* str)
{
    str->ch = NULL;
    str->length = 0;
}

/** 使用暴风算法返回子串在主串中的位置 */
int BFCompare(HString* parent, HString* child, int pos)
{
    int i = pos;    //i用于主串parent中的起始位置
    int j = 1;      //子串的起始位置
    while (i <= parent->length && j <= child->length)
    {
        //i和j都为初始位置，在数组中要-1才能表示其下标
        if (parent->ch[i - 1] == child->ch[j - 1])
        {
            i++;
            j++;
        }
        else 
        {
            i = i - j + 2;  //i回朔到上次匹配的首位的下一位
            j = 1;          //j回到子串的第一个位置
        }
    }
    //当j大于子串长度，说明匹配成功，返回主串中第一个相同元素的下标
    if (j > child->length) 
    {
        return i - child->length;
    }
    return 0;
}

KMP算法：

特点：速度快

思路如下：

匹配过程中出现字符比较不等

不回溯主指针 i

利用已得到的“部分匹配”结果将模式向右滑动尽可能远的一段距离

注意：如果有多个匹配字符，则用最远的那一个

那么部分匹配是指哪些部分呢？

前缀：除了最后一个字符外，一个字符串的全部头部组合

后缀：除了第一个字符外，一个字符串的全部尾部组合

部分匹配值（最大共有长度）具体算法如下：

/** 串的堆式顺序存储结构（Heap） */
typedef struct 
{
    char* ch;      //如果是非空串，那么就按照指定长度分配内存，否则ch就指向NULL
    int length;     //串的当前长度
}HString;
/** 初始化堆字符串 */
void InitString_HeapString(HString* str) 
{
    str->ch = NULL;
    str->length = 0;
}
/** 返回next数组（部分匹配表） */
void Get_Next(HString child, int* next) 
{
    int i = 0;
    int j = -1;//用j来统计最大匹配长度
    next[0] = -1;
    while (i < child.length) 
    {
        if (j == -1 || child.ch[i] == child.ch[j]) 
        {
            i++;
            j++;
            next[i] = j;
        }
        else 
        {
            j = next[j];
        }
    }
}

/** 使用KMP算法进行比较，返回子串在主串中的位置 */
int KMPCompare(HString* parent, HString* child, int pos) 
{
    int next[255];  //用来存放部分匹配值
    Get_Next(*child, next); //首先处理子串，计算出部分匹配值
    int i = pos - 1;
    int j = 0;
    while (i < parent->length && j < child->length) 
    {
        if (j == -1 || parent->ch[i] == child->ch[j]) 
        {
            i++;
            j++;
        }
        else 
        {
            j = next[j];
        }
    }
    if (j == child->length) 
    {
        return (i + 1) - j;
    }
    return 0;
}