數據結構-串的定長順序存儲

串的定長順序存儲類似於線性表的順序存儲結構，用一組連續的存儲單元存儲串值的字符序列。

在串的定長順序存儲結構中，按照預定義的大小，為每個定義的串變量分配一個固定長度的存儲區，則可以用定長數組表示：

/*串定長順序存儲表示*/
#define MAXSTRLEN 255        //串在MAXSTRLEN大小
typedef unsigned char SString[MAXSTRLEN + 1];    //所有串的0號單元存儲串的長度

串的基本操做函數如下：

/*生成一個其值等於chars的串T*/
Status StrAssign(SString &T, char chars[])
{
    if(strlen(chars) > MAXSTRLEN)
        return ERROR;
    T[0] = strlen(chars);
    for (int i = 0; i <= T[0]; i++)
        T[i+1] = chars[i];
    return OK;
}

/*由串S賦值的到串T*/
Status StrCopy(SString &T, SString S)
{
    int i = 1;
    for (; i <= S[0]; i++)
        T[i] = S[i];
    T[0] = S[0];
    return OK;
}

/*判斷串S是否為空，若S為空串側返回true，否則返回false*/
bool StrEmpty(SString s)
{
    if(s[0] == 0)
        return true;
    else
        return false;
}

/*若S>T，則返回值大於0；若S=T，則返回值等於0；若S<T則返回值小於0*/
Status StrCompare(SString S, SString T)
{
    for (int i = 1; i <= S[0] && i <= T[0]; ++i)
        if(S[i] != T[i])
            return S[i] - T[i];
    return S[0] - T[0];
}

/*返回串的長度*/
int StrLength(SString S)
{
    return S[0];    //串的第0個存儲放的串的長度
}

/*重置串為空串*/
Status ClearString(SString &S)
{
    S[0] = 0;    //因為是順序存儲，只要將長度標志設為0即是代表已經清空串
    return OK;
}

/*用T返回由串S1和串S2連接成的新串。若未截斷，則返回true，否則返回false*/
bool Concat(SString &T, SString S1, SString S2)
{
    bool uncut = true;
    if(S1[0] + S2[0] <= MAXSTRLEN)    //未截斷
    {
        for (int i = 1; i <= S1[0]; i++)
            T[i] = S1[i];
        for (int i = 1; i <= S2[0]; i++)
            T[i + S1[0]] = S2[i];
        T[0] = S1[0] + S2[0];
        uncut = true;
    }
    else if(S1[0] < MAXSTRLEN)    //截斷；只取S2的一部分
    {
        int i = 1;
        for ( ; i <= S1[0]; i++)
            T[i] = S1[i];
        for (i = 1; i <= MAXSTRLEN-S1[0]; i++)
            T[i + S1[0]] = S2[i];
        T[0] = MAXSTRLEN;
        uncut = false;
    }
    else                    //截斷；僅取S1
    {
        for (int i = 0; i <= MAXSTRLEN; i++)
            T[i] = S1[i];
        uncut = false;
    }
    return uncut;
}

/*用sub返回串S的第pos個字符起的長度為len的子串*/
Status SubString(SString &Sub, SString S, int pos, int len)
{
    if(pos < 1 || pos > S[0] || len < 0 || len > S[0]-pos+1)
        return ERROR;
    for (int i = 1; i <= len; i++)
        Sub[i] = S[pos+i-1];
    Sub[0] = len;
    return OK;
}
/*用串V替換主串中出現的所有*/
Status Replace(SString &S, SString T, SString V)
{
    if(StrEmpty(T))
        return ERROR;
    int i = 1, j = 1;
    int m = StrLength(T), n = StrLength(V);
    while(i <= S[0])
    {
        j = Index(S,T,i);
        StrDelete(S,j,m);
        StrInsert(S,j,V);
        i+=n+1;
    }
    return OK;
}

/*在串S的pos位置之前插入串T*/
Status StrInsert(SString &S, int pos, SString T)
{
    if(pos < 1 || pos > S[0]+1)
        return ERROR;
    if(S[0]+T[0] <= MAXSTRLEN)    //完全插入
    {
        for (int i = S[0]; i >= pos; i--)
            S[i+T[0]] = S[i];
        for (int i = pos; i < pos+T[0]; i++)
            S[i] = T[i-pos+1];
        S[0] = S[0]+T[0];
        return OK;
    }
    else    //不完全插入
    {
        for (int i = MAXSTRLEN; i >= pos; i--)
            S[i] = S[i-T[0]];
        for (int i = pos; i < pos+T[0]; i++)
            S[i] = T[i-pos+1];
        S[0] = MAXSTRLEN;
        return ERROR;
    }
}

/*從串S中刪除第pos個字符起的長度為len的子串*/
Status StrDelete(SString &S, int pos, int len)
{
    if(pos < 1 || pos > S[0]-len+1 || len < 0)
        return ERROR;
    for (int i = pos+len; i <= S[0]; i++)
        S[i-len] = S[i];
    S[0] -= len;
    return OK;
}

/*銷毀串S*/
Status DestroyString(SString &S)
{
    free(S);
    return OK;
}

/*輸出串*/
void StrPrint(SString T)
{
    for (int i = 1; i <= T[0]; i++)
        printf("%c",T[i]);
    printf("\n");
}

還有一個函數Index函數。做字符串匹配用，這里拿出來單獨討論

/*若主串S中存在和串T值相同的子串；
/*則返回他在主串S中第pos個字符之后第一次出現的位置；
/*否則函數值為0*/
int Index(SString S, SString T, int pos)
{
    /*調用串基本操作的方法，也是Index函數的思想步驟*/
    //if(pos > 0)
    //{
    //    int n = StrLength(S);    //獲取串的長度
    //    int m = StrLength(T);
    //    int i = pos;
    //    SString sub;
    //    while(i <= n-m+1)        //循環值從pos到串S的最后一個T長度位置
    //    {
    //        SubString(sub,S,i,m);    //獲取子串，S的第i個位置開始長度m-1的子串
    //        if(StrCompare(sub,T) != 0)    //判斷獲取的子串與串T是否不等；如果相等返回i的值也就是第一次出現的位置
    //            ++i;
    //        else
    //            return i;
    //    }
    //}
    //return 0;    //沒有出現返回0

    /*定位函數Index的模式匹配算法
    /*算法的基本思想：
    /*從主串S的第pos個字符起和模式的第一個字符比較之，
    /*若相等，則繼續逐個比較后續字符；
    /*否則從主串的下一個字符起再重新和模式的字符比較之。
    /*以此類推，直至模式T中的每個字符依次和主串S中的一個連續的字符序列相等，則匹配成功；
    /*函數值為和模式T中的第一個字符相等的字符在主串S中的序號。
    /*否則匹配不成功，函數值為零。*/
    int i = pos,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];    //匹配成功
    return 0;                //匹配失敗
}

其中這個函數內寫了兩種方法：第一種調用基本函數的方法，第二種模式匹配算法。

但模式匹配算法還有一個很是經典的算法模式匹配的改進算法-KMP算法；

其改進在於：每當一趟匹配過程中出現字符比較不等時，不需回溯i指針，而是利用已經得到的“部分匹配”的結果將模式向右滑動盡可能遠的一段距離后，繼續進行比較。

KMP算法的基本思想就是這樣，剩下的百度搜索全是我就不再細說，還是按我的習慣直接上代碼。

void get_next(SString T, int *next) {
  int i=1;
  next[1]=0;
  int j=0;
  while (i<T[0]) {
    if(j==0 || T[i]== T[j]) {
      ++i;  ++j;  next[i] = j;
    } else j= next[j];
  }
}

int Index_KMP(SString S, SString T, int pos) {
  // 利用模式串T的next函數求T在主串S中第pos個字符之后的位置的
  // KMP算法。其中，T非空，1≤pos≤StrLength(S)。
  int next[255];
  int i = pos;
  int j = 1;
  get_next(T, next);
  while (i <= S[0] && j <= T[0]) {
    if (j == 0 || S[i] == T[j]) {  // 繼續比較后繼字符
      ++i;  ++j;
    } else j = next[j]; // 模式串向右移動
  }
  if (j > T[0]) return  i-T[0];   // 匹配成功
  else return 0;
}

KMP算法時間復雜度O（m）。通常，模式串的長度m比主串的長度n要小的多，因此對整個匹配算法來說，所增加的這點時間是值得的。

但是，雖然模式匹配算法時間復雜度是O（n*m），但是一般情況下，其實際的實行時間近似於O（n+m），因此至今仍被采用。

KMP算法僅當模式與主串之間存在許多“部分匹配”的情況下才顯得比模式匹配算法快得多。但是KMP算法的最大特點是指主串的指針不需回溯，整個匹配過程中，對主串僅需從頭至尾掃描一遍，這對處理從外設輸入的龐大文件很有效，可以邊讀入邊匹配，而無需回溯重讀。

 

但對於next函數前面所寫的在某些情況下有一個缺陷，例如在模式aaaab，主串aaabaaaab匹配時，當i=4，j=4時ch[4]！=t.ch[4]。由next[j]的指示還需要進行i=4，j=3；i=4，j=2；i=4，j=1這三次比較。實際上，因為模式中第1,2,3個字符和第4個字符都相等，因此不必要在和主串中第4個字符相比較，而可以將模式一下子滑動4個位置。直接進行i=5，j=1時的字符比較。

j	1 2 3 4 5
模式	a a a a b
next[j]	0 1 2 3 4
nextval[j]	0 0 0 0 4

 

改進的next函數如下：此時匹配算法不變；

void get_nextval(SString T, int *nextval) {
  // 求模式串T的next函數修正值並存入數組nextval。
  int i = 1;
  int j = 0;
  nextval[1] = 0;
  while (i<T[0]) {
    if (j==0 || T[i]==T[j]) {
      ++i;  ++j;
      if (T[i]!=T[j]) nextval[i] = j;
      else nextval[i] = nextval[j];
    }
    else j = nextval[j];
  }
}