串和模式匹配
数据结构串串的基本概念串的存储结构与实现串的模式匹配

t.ch[i]=s2.ch[i-s1.length]; }
串删除
void strdelete(Hstring &s,int pos,int len) {
if(pos<1||pos>s.length-len+1||len<0||len>s.length){ cout<<"删除位置不合法"<<endl; return;
int flag=0; int i=0,j=1; if(s1[0]+s2[0]<=MAXSTRLEN) {
for(i=1;i<=s1[0];i++) t[i]=s1[i];
for(i=s1[0]+1;i<=s1[0]+s2[0];i++) t[i]=s2[j++];
t[0]=s1[0]+s2[0]; flag=1; //未截断 }
strempty(s) 初始条件:s为一个串 操作结果:若s为空串,则返回1
strcopy(&t,s) 初始条件:s为一个串 操作结果:把串s复制给t
strncpy(&sub,s,pos,len) 初始条件:s为一个串,pos为起始位置, 1≤pos≤strlength(s)-1,len≥0 操作结果:用sub返回串s的第pos个字符开⑩长度为len的子串
例:模式串t=“abcac”和主串s=“ababcabcaccabbc”匹配过程
第三二一 趟 a b a b c a b c a c c a b b c i=112734568901
串的模式匹配算法

串串(String)又叫做字符串,是一种特殊的线性表的结构,表中每一个元素仅由一个字符组成。
随着计算机的发展,串在文字编辑、词法扫描、符号处理以及定理证明等诸多领域已经得到了越来越广泛的应用。
第一节串的定义和表示1、串的逻辑结构定义串是由零个到任意多个字符组成的一个字符序列。
一般记为:S=’ a1a2a3……a n’(n>=0)其中S为串名,序列a1a2a3……a n为串值,n称为串的长度,我们将n=0的串称为空串(null string)。
串中任意一段连续的字符组成的子序列我们称之为该串的子串,字符在序列中的序号称为该字符在串中的位置。
在描述中,为了区分空串和空格串(s=‘’),我们一般采用来表示空串。
2、串的基本操作串一般包含以下几种基本的常用操作:1、length(S),求S串的长度。
2、delete(S,I,L),将S串从第I位开始删除L位。
3、insert(S,I,T),在S的第I位之前插入串T。
4、str(N,S),将数字N转化为串S。
5、val(S,N,K),将串S转化为数字N;K的作用是当S中含有不为数字的字符时,K记录下其位置,并且S没有被转化为N。
3、串的储存结构一般我们采用以下两种方式保存一个串:1、字符串类型,描述为:const n=串的最大长度type strtype=string[n]这里由于tp的限制,n只能为[1..255]。
在fp或者delphi中,我们还可以使用另外一种类型,描述为:const n=串的最大长度type strtype=qstring[n]这里的n就没有限制了,只要空间允许,开多大都可以。
2、数组来保存,描述为:const n=串的最大长度type strtype=records:array[1..n] of char;len:0..n;end;第二节模式匹配问题与一般的线性表不同,我们一般将串看成一个整体,它有一种特殊的操作——模式匹配。
串的模式匹配算法实验报告

竭诚为您提供优质文档/双击可除串的模式匹配算法实验报告篇一:串的模式匹配算法串的匹配算法——bruteForce(bF)算法匹配模式的定义设有主串s和子串T,子串T的定位就是要在主串s中找到一个与子串T相等的子串。
通常把主串s称为目标串,把子串T称为模式串,因此定位也称作模式匹配。
模式匹配成功是指在目标串s中找到一个模式串T;不成功则指目标串s中不存在模式串T。
bF算法brute-Force算法简称为bF算法,其基本思路是:从目标串s的第一个字符开始和模式串T中的第一个字符比较,若相等,则继续逐个比较后续的字符;否则从目标串s的第二个字符开始重新与模式串T的第一个字符进行比较。
以此类推,若从模式串T的第i个字符开始,每个字符依次和目标串s中的对应字符相等,则匹配成功,该算法返回i;否则,匹配失败,算法返回0。
实现代码如下:/*返回子串T在主串s中第pos个字符之后的位置。
若不存在,则函数返回值为0./*T非空。
intindex(strings,stringT,intpos){inti=pos;//用于主串s中当前位置下标,若pos不为1则从pos位置开始匹配intj=1;//j用于子串T中当前位置下标值while(i j=1;}if(j>T[0])returni-T[0];elsereturn0;}}bF算法的时间复杂度若n为主串长度,m为子串长度则最好的情况是:一配就中,只比较了m次。
最坏的情况是:主串前面n-m个位置都部分匹配到子串的最后一位,即这n-m位比较了m次,最后m位也各比较了一次,还要加上m,所以总次数为:(n-m)*m+m=(n-m+1)*m从最好到最坏情况统计总的比较次数,然后取平均,得到一般情况是o(n+m).篇二:数据结构实验报告-串实验四串【实验目的】1、掌握串的存储表示及基本操作;2、掌握串的两种模式匹配算法:bF和Kmp。
3、了解串的应用。
【实验学时】2学时【实验预习】回答以下问题:1、串和子串的定义串的定义:串是由零个或多个任意字符组成的有限序列。
第5章-串

子串,s旳串值变化。
5-2 串旳表达和实现
一.串旳顺序存储
1.存储方式:同一般旳线性表旳顺序存储构 造完全相同.用一组地址连续旳存储单元存 储字符序列, 据预定义大小,为每个定义旳串 变量分配一种固定长度旳存储区。
2.索引存储旳例子 设字符串:A=”Red” B=”Yellow” C=”Blue” D=”White” 用指针free指向堆中未使用空间旳首地址。
索引表: Name A B C D ……
Length 3 6 4 5 ……
Stradr 0 3 9
……
free 堆:
R e d Y e l l o w B l u E Wh i t e …
为 len 旳子串。而且赋予给s2,len=0得到旳是空串。 【例5-7】 SubStr ("abcdefghi",3,4) = "cdef”
4. 串比较: Strcmp (s1,s2) 操作条件:串s1,s2存在。 操作成果:若s1= =s2,返回值为0;若s1<s2, 返
回值<0;若s1>s2, 返回值>0。
(2)使用gets() 函数
格式为:gets(字符数组名); 【例5-3】 char str[10]; printf("Input your str: "); gets(str);
•使用gets ()方式输入时,字符串中允许具有空
格。
2.字符串旳输出
字符串旳输出也有两种措施:
(1)使用printf () 函数 使用printf () 函数时,输出格式中要设置"%s",再
止符,以此表达串旳结尾。例如C语言中处理定长串旳措施
第4章串(String)(2)专题知识讲座

BF算法旳基本思想图解 本趟匹配开始位置
主串S 模式T
回溯 i
si
…
tj
j 回溯
……
25
BF算法用伪代码 : 1. 在串S和串T中设比较旳起始下标i和j; 2. 循环直到S中所剩字符个数不大于T旳长度或T旳
全部字符均比较完 2.1 假如S[i]=T[j],继续比较S和T旳下一种字符; 2.2 不然将i和j回溯(j=0, i为此次比较旳最初字符 旳下一种字符旳下标),准备下一趟比较; 3. 假如T中全部字符均比较完,则匹配成功,返回 匹配旳起始比较下标;不然,匹配失败,返回0;
4
二、串旳抽象数据类型
数据集合:串旳数据集合能够表达为字符序列 s0,s1, ……,sn-1,每
个数据元素旳数据类型为字符类型。
操作集合:
(1)初始化串 Initiate(S)
(2)赋值
Assign( S, T)
(3)求串长度 strLength( S )
(4)比较
Compare( S, T)
(5)插入
13
2、顺序串旳紧缩存储方式
以字节为单位顺序存储字符串旳每个字符,根据机器字旳 长度,紧缩存储措施尽量地将多种字符存储在一种字中。 对于字符串s =“data structures”,非紧缩存储方式下字 符串s旳顺序存储构造如下:(假设字长为4)
14
2、串旳链式存储构造
它分为单字符结点和块链两种。
18
b.链串
(1)链串赋值
void strassign(linkstring *s, char t[])
{
int k=0; linkstring *r,*p;
s = (linkstring *)malloc(sizeof(linkstring)); s->data = ‘#’; r=s; while (t[k]!=‘\0’) { p=(linkstring *) malloc(sizeof(linkstring));
串的模式匹配算法

串的模式匹配算法字符串模式匹配是计算机科学中一种常用的算法。
它是一种检索字符串中特定模式的技术,可以用来在字符串中查找相应的模式,进而完成相应的任务。
字符串模式匹配的基本思想是,用一个模式串pattern去匹配另一个主串text,如果在text中找到和pattern完全匹配的子串,则该子串就是pattern的匹配串。
字符串模式匹配的过程就是在text中搜索所有可能的子串,然后比较它们是否和pattern完全匹配。
字符串模式匹配的算法有很多,其中著名的有暴力匹配算法、KMP算法、BM算法和Sunday算法等。
暴力匹配算法是最简单也是最常用的字符串模式匹配算法,其思想是从主串的某一位置开始,依次比较pattern中每一个字符,如果某个字符不匹配,则从主串的下一位置重新开始匹配。
KMP算法(Knuth-Morris-Pratt算法)是一种更为高效的字符串模式匹配算法,它的特点是利用了已匹配过的字符的信息,使搜索更加有效。
它的实现思想是,在pattern中先建立一个next数组,next数组的值代表pattern中每个字符前面的字符串的最大公共前缀和最大公共后缀的长度,这样可以在主串和模式串匹配失败时,利用next数组跳转到更有可能匹配成功的位置继续搜索,从而提高字符串模式匹配的效率。
BM算法(Boyer-Moore算法)也是一种高效的字符串模式匹配算法,它的实现思想是利用主串中每个字符最后出现的位置信息,以及模式串中每个字符最右出现的位置信息来跳转搜索,从而减少不必要的比较次数,提高搜索效率。
Sunday算法是一种简单而高效的字符串模式匹配算法,它的实现思想是,在主串中搜索时,每次从pattern的最右边开始比较,如果不匹配,则根据主串中下一个字符在pattern中出现的位置,将pattern整体向右移动相应位数,继续比较,这样可以减少不必要的比较次数,提高算法的效率。
字符串模式匹配算法的应用非常广泛,它可以用来查找文本中的关键字,检查一个字符串是否以另一个字符串开头或结尾,查找文本中的模式,查找拼写错误,检查字符串中是否包含特定的字符等。
串的两种模式匹配算法

串的两种模式匹配算法 模式匹配(模范匹配):⼦串在主串中的定位称为模式匹配或串匹配(字符串匹配) 。
模式匹配成功是指在主串S中能够找到模式串T,否则,称模式串T在主串S中不存在。
以下介绍两种常见的模式匹配算法:1. Brute-Force模式匹配算法暴风算法,⼜称暴⼒算法。
算法的核⼼思想如下: 设S为⽬标串,T为模式串,且不妨设: S=“s0s1s2…sn-1” , T=“t0t1t2 …tm-1” 串的匹配实际上是对合法的位置0≦i≦n-m依次将⽬标串中的⼦串s[i…i+m-1]和模式串t[0…m-1]进⾏⽐较:若s[i…i+m-1]=t[0…m-1]:则称从位置i开始的匹配成功,亦称模式t在⽬标s中出现;若s[i…i+m-1]≠t[0…m-1]:从i开始的匹配失败。
位置i称为位移,当s[i…i+m-1]=t[0…m-1]时,i称为有效位移;当s[i…i+m-1] ≠t[0…m-1]时,i称为⽆效位移。
算法实现如下: (笔者偷懒,⽤C#实现,实际上C# String类型已经封装实现了该功能)1public static Int32 IndexOf(String parentStr, String childStr)2 {3 Int32 result = -1;4try5 {6if (parentStr.Length > 1 && childStr.Length > 1)7 {8 Int32 i = 0;9 Int32 j = 0;10while (i < parentStr.Length && j < childStr.Length)11 {12if (parentStr[i] == childStr[j])13 {14 i++;15 j++;16 }17else18 {19 i = i - j + 1;20 j = 0;21 }22 }23if (i < parentStr.Length)24 {25 result = i - j;26 }27 }28 }29catch (Exception)30 {31 result = -1;32 }33return result;34 } 该算法的时间复杂度为O(n*m) ,其中n 、m分别是主串和模式串的长度。
串的模式匹配算法

/* 在目标串s中找模式串t首次出现的位置,若不存在返回0。采用定长顺序
存储结构第二种方式存放串S和串T */
{
int i,j;
for(i=1,j=1;i<=s.length&&j<=t.length;)
{if(s.ch[i-1]==t.ch[j-1])
{i++;j++;}
/*字符比较成功,继续比较后续字符*/
设有两个串S和T,其中: S="s1s2s3…sn" T="t1t2t3…tm"(1≤m≤n,通常有m<n)
模式匹配算法的基本思想是:用T中字符依次与S中 字符比较:从S中的第一个字符(i=1)和T中第一个字 符( j=1)开始比较,如果s1=t1,则i和j各加1,继续 比较后续字符,若s1=t1,s2=t2,…,sm=tm, 返回1;否则,一定存在某个整数j(1≤j≤m)使得si≠tj ,即第一趟匹配失败,一旦出现这种情况,立即中断 后面比较,将模式串T向右移动一个字符执行第二趟 匹配步骤,即用T中第一个字符( j=1)与S中的第2个字 符(i=2)开始依次比较;
数据结构
串的模式匹配算法
基本的模式匹配算法
子串定位操作又称为串的模式匹配(Pattern Matching)或串匹配,该操作是各种串处理系统中的 重要操作之一 。
子串定位操作是要在主串中找出一个与子串相同的 子串。一般将主串称为目标串,子串称之为模式串。 设S为目标串,T为模式串,把从目标串S中查找模式串 T的过程成为“模式匹配”。匹配的结果有两种:如果 S中有模式为T的子串,则返回该子串在S中的位置,若 S中有多个模式为T的子串时,则返回的是模式串T在S 中第一次出现的位置,这种情况称匹配成功;否则,称 为匹配失败。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
int operator!= (char *s) const;
friend int operator!= (char *str, const String& s);
int operator< (const String& s) const;
String& String::operator= (char *s) { int slen = strlen(s) + 1;
// if sizes differ, delete current string and reallocate
if (slen != size) { delete [] str; str = new char [slen]; if (str == NULL) Error(outOfMemory); size = slen; } strcpy(str,s); return *this;
电子系1999级
数据结构
Data Structure With C or C++
串
串---由字符组成的线性表,也叫 字符串 串是非数值计算算法处理的主要 对象 在模式匹配,程序编译,数据处 理等领域有广泛的应用
串类型的定义
串类型的实现 串的模式匹配
串类型的定义
1。用数组定义串 #define MAXSTRLEN 255 typedef unsigned SString[MAXSTRLEN+1];
int operator== (char *str, const String& s) { return strcmp(str,s.str) == 0; }
// String != String
int String::operator!= (const String& s) const { return strcmp(str,s.str) != 0; }
// String < String
int String::operator< (const String& s) const { return strcmp(str,s.str) < 0; }
// String < C++String
int String::operator< (char *s) const { return strcmp(str,s) < 0; }
// String I/O
friend ostream& operator<< (ostream& ostr,
const String& s); friend istream& operator>> (istream& istr, String& s); int ReadString(istream& is=cin, char delimiter='\n'); int Length(void) const;
// allocate same amount of space as s uses. copy string
str = new char [size]; if (str == NULL) Error(outOfMemory); strcpy(str, s.str); }
// destructor
String& operator= (const String& s); String& operator= (char *s); int operator== (const String& s) const; int operator== (char *s) const;
friend int operator== (char *str, const String& s);
if (str == NULL) Error(outOfMemory); strcpy(str,s); }
// copy constructor String::String(const String& s) {
// current object as length of s
size = s.size;
堆分配存储串类的实现//“strclass.h” #ifndef STRING_CLASS
#define STRING_CLASS
#include <iostream.h> #include <string.h>
#include <stdlib.h>
#ifndef NULL
const int NULL = 0;
// String != C++String
int String::operator!= (char *s) const { return strcmp(str,s) != 0; }
// C++String != String
int operator!= (char *str, const String& s) { return strcmp(str,s.str) != 0; }
String::~String(void) { delete [] str; }
// assignment operator. String to String
String& String::operator= (const String& s) { if (s.size != size) { delete [] str; str = new char [s.size]; if(str == NULL) Error(outOfMemory);
// String <= C++String
int String::operator<= (char *s) const { return strcmp(str,s) <= 0; }
// C++String <= String
int operator<= (char *str, const String& s) { return strcmp(str,s.str) <= 0; }
Sstring s1, s2; //用s1[0], s2[0]存储各自的长度
2。堆分配存储表示
typedef struct{ char *ch; int length; }HString;
HString s; s.length=15; s.ch=new char[s.length];
3.块链存储
#define CHUNKSIZE 80 typedef struct Chunk{ char ch[CHUNKSIZE]; Chunk *next; }; typedef struct{ Chunk *head,*tail; int curlen; }LString; //定长字符串作元素的线性链表
int operator< (char *s) const;
friend int operator< (char *str, const String& s);
int operator<= (const String& s) const; int operator<= (char *s) const;
int operator>= (const String& s) const;
int operator>= (char *s) const;
friend int operator>= (char *str, const String& s);
String operator+ (const String& s) const; String operator+ (char *s) const;
// C++String < String
int operator< (char *str, const String& s) { return strcmp(str,s.str) < 0; }
// String <= String
int String::operator<= (const String& s) const { return strcmp(str,s.str) <= 0; }
#endif // NULL const int outOfMemory = 0, indexError = 1;
class String
{ char *str; int size;
void Error(int errorType, int badIndex = 0) const;
public: String(char *s = “ ” ); String(const String& s); ~String(void);
// constructor. allocate memory and copy in a C++String
String::String(char *s) { size = strlen(s) + 1; str = new char [size];
// terminate program if memory is exhausted.
// String == C++String
int String::operator== (char *s) const { return strcmp(str,s) == 0; }