数据结构看书笔记（五）--串

串：
 　　串（string）是由零个或多个字符组成的有限序列，又名叫字符串。
　　 一般记为s=“a1a2……an”(n>=0)。串中的字符数目n称为串的长度,零个字符的字符串称为空串(null string)。
 
　　 空格串是只包含空格的串，空格串是有内容有长度的。
 
　　 子串与主串，串中的任意个数的连续字符组成的子序列称为该串的子串，相应的，包含子串的串称为主串。

串的比较：
 　　对于两个串不相等时，如何判断他们的大小呢。我们这样定义:
 　　给定两个串：s="a1a2……an",t="b1b2……bm"，当满足以下条件之一时，s<t。
 　　1.n<m，且ai=bi（i=1,2，……，n）。
 　　2.存在某个k<=min(m,n),使得ai=bi(i=1,2,……，k-1),ak<bk.

串的抽象数据类型：

    ADT 串(string)
    Data
        串中元素仅由一个字符组成，相邻元素具有前驱和后继关系。
    Operation
        StrAssign(T,*chars):生成一个其值等于字符串常量chars的串T。
        StrCopy(T,S):串S存在，由串S复制得串T。
        ClearString(S):串S为空，返回true，否则返回false。
        StringEmpty(S):若串为空则返回true,否则返回false。
        StrLength(S):返回串S的元素个数，即串的长度
        StrCompare(S,T):若S>T，返回值>0,若S=T,返回0，若S<T，返回值<0.
        Concat(T,S1,S2):用T返回由S1和S2联接而成的新串。
        SubString(Sub,S,pos,len):串S存在,1<=pos<=StrLength(S),且0<=len<=StrLength(S)-pos+1，用Sub返回串S的第pos个字符起长度为len的子串
        Index(S,T,pos):串S和T存在，T是非空串，1<=pos<=StrLength(S).若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。
        Replace(S,T,V):串S、T和V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串。
        StrInsert(S,pos,T):串S和T存在，1<=pos<=StrLength(S)+1.在串S的第pos个字符之前插入串T。
        StrDelete(S,pos,len):串S存在，1<=pos<=StrLength(S)-len+1.从串S中删除第pos个字符起长度为len的子字符串。
    endADT

    //操作Index的算法
    int Index(String S,String T,int pos)
    {
        int n,m,i;
        String sub;
        if(pos>0)
        {
            n = StrLength(S);
            m = StrLength(T);
            i = pos;
            while(i<=n-m+1)
            {
                SubString(sub,S,i,m);
                
                if(StrCompare(sub,T)!=0)
                    ++i;
                else
                    return i;
            }
        }
        return 0;
    }

操作Index的算法

串的存储结构：
 　　串的顺序存储结构
 　　串的链式存储结构
  　　　　串的链式存储结构除了在连接串与串操作时有一定方便之外，总的来说不如顺序存储灵活，性能也不如顺序存储结构好。

朴素的模式匹配算法：
　　子串的定位操作常常称为串的模式匹配。

　　假设主串S和子串T的长度存在S[0]和T[0]中。实现代码如下：

    int Index(String S,String T，int pos)
    {
        int i = pos;
        int j = 1;
        while(i<=S[0]&&j<=T[0])
        {
            if(S[i]==T[j])
            {
                ++i;
                ++j;
            }
            else 
            {
                i = i-j=2;
                j = 1;
            }
        }
        if(j>T[0])
            return i-T[0];
        else 
            return 0;
    }   

KMP模式匹配算法
 　　一个模式匹配算法，可以大大避免重复遍历的情况，我们把它称之为克努特——莫里斯——普拉特算法，简称为KMP算法。
 
 　　next 数组的推导
 　　（大话数据结构p139--p140）

    void get_next(String T，int *next)
    {
        int i,j;
        i = 1;
        j = 0;
        next[1] = 0;
        while(i<T[0])
        {
            if(j==0||T[i]==T[j])
            {
                ++i;
                ++j;
                next[i]=j;
            }
        }
        else
            j=next[j];
    }
    
    int  Index_KMP(String S,String T,int pos)
    {
        int i = pos;
        int j = 1;
        int next[255];
        get_next(T,next);
        while(i<=S[0]&&j<=T[0])
        {
            if(j==0||S[i]==T[i])
            {
                ++i;
                ++j;
            }
            else
            {
                j = next[j];
            }
        }
        if(j>T[0])
            return i-T[0];
        else    
            return 0;
    }

KMP模式匹配算法实现

算法改进//过后补充

转载于:https://www.cnblogs.com/lazyfennec/p/6289091.html