字串

1.串的定義

串是由零個或多個字元組成的有限序列，一般記為

串的原子操作（其餘操作可以以下操作組合完成）包含以下5種：

1. 串賦值StrAssign
2. 串比較StrCompare
3. 求串長StrLength
4. 串連線Concat
5. 求子串SubString

2. 串的表示與實現

串有3種表示方式：

1. 定長順序儲存（定長）
2. 堆分配儲存（順序表）
3. 塊串儲存（連結串列）

2.1 定長順序儲存

定長順序儲存用一組地址連續的儲存單元儲存字元序列。其定義如下

//----------------定長順序儲存------------
/**
 * 定長串約定：
 * 1.0號下表表示為串長
 * 2.當串長長度超過MAX_SIZE時進行截斷
 */
#define MAX_SIZE  255
typedef unsigned char SString[MAX_SIZE + 1 + 1];        //0號下標儲存字串的長度,C語言特性字串最後一個尾'\0'

下面來分別實現上述5個原子操作：

2.1.1串賦值StrAssign

/**
 * 字串分配，將str分配到T中
 * @param T
 * @param str
 * @return
 

 */
Status strAssign(SString &T,char *str){
    int length = 0;
    char *p_c = str;
    for(;*p_c!='\0';length++,p_c++);      //求字串str的長度
    if(length > MAX_SIZE){
        T[0] = MAX_SIZE;
        for(int i = 1;i<=MAX_SIZE;i++){     //超過maxsize的進行截斷
            T[i] = str[i-1];
        }
        T[T[0
 
] + 1] = '\0';
    }else{
        T[0] = length;
        for(int i = 1;i<=length;i++){
            T[i] = str[i-1];
        }
        T[T[0] + 1] = '\0';
    }
    return OK;
}

2.1.2 串比較StrCompare

/**
 * 比較S和T
 * @param S
 * @param T
 * @return  S>T 返回>0
 *          S<T 返回<0
 *          S=T 返回0
 */
Status strCompare(SString &S, SString &T){
    for(int i = 0;i<S[0] && i<T[0];i++){
        if(S[i+1] != T[i+1]) return S[i+1] - T[i+1];
    }
    return S[0] - T[0]; //某一個串是另一串的子串時，比較哪個串更長
}

2.1.3 求串長

/**
 * 求串長
 * @param S
 * @return
 */
int strLength(SString &S){
    return S[0];
}

2.1.4 串連線Concat

/**
 * 串連線，將S1和S2拼接成新串T。
 * 由於定長串固有的缺點，分為以下三種情況：
 * 1.S1，S2在拼接過程中均未截斷
 * 2.S1，S2在拼接過程中S2被截斷
 * 3.S1，S2在拼接過程中S1和S2均被截斷（S1部分截斷，S2全部截斷）
 * @param T
 * @param S1
 * @param S2
 * @return OK
 *
 */
Status Concat(SString &T,SString S1,SString S2){
    if(S1[0] + S2[0] <= MAX_SIZE){
        T[0] = S1[0] + S2[0];
        for(int i = 1;i<=S1[0];i++){
            T[i] = S1[i];
        }
        for(int i = 1+S1[0];i<= S1[0]+S2[0];i++){
            T[i] = S2[i - S1[0]];
        }
        T[T[0] + 1] = '\0';
    }else if(S1[0] <= MAX_SIZE){
        T[0] = MAX_SIZE;
        for(int i = 1;i<=S1[0];i++){
            T[i] = S1[i];
        }
        for(int i = 1+S1[0];i<=MAX_SIZE;i++){
            T[i] = S2[i-S1[0]];
        }
        T[T[0] + 1] = '\0';
    }else{
        T[0] = MAX_SIZE;
        for(int i =1;i<=MAX_SIZE;i++){
            T[i] = S1[i];
         }
        T[T[0] + 1] = '\0';
    }
    return OK;
}

2.1.5 求子串SubString

/**
 * 求S的一個子串，其位置在pos->pos+len-1
 * @param Sub
 * @Param S
 * @param pos
 * @param len
 * @return
 */
Status SubString(SString &Sub,SString S,int pos,int len){
    //判定位置
    if(pos<1 || pos> S[0] || len <0 || pos+len -1 > S[0]) exit(ERROR);
    Sub[0] = len;
    for(int i = 1;i<=len;i++){
        Sub[i] = S[i+pos-1];
    }
    Sub[Sub[0] + 1] = '\0';
    return OK;
}

2.2 堆分配儲存表示

在順序儲存結構中，實現串操作的源操作為“字元序列的賦值”，操作的時間複雜度基於賦值的字元序列的長度。另一操作特點是，如果在操作中出現串序列超過上界，會出現截斷的情況，為客服這個缺點，可通過動態分配串值得儲存空間。基於堆分配儲存的定義如下:

//---------------堆分配字串------------
typedef struct{
    char *ch;
    int length;
}HString;

下面來實現5個原子操作：

2.2.1 串賦值StrAssign

/**
 * 分配
 * @param T
 * @param chars
 * @return
 */
Status StrAssign(HString &T,char *chars){
    if(T.ch) free(T.ch); T.ch = NULL;
    int length;
    char *c = chars;
    for(length = 0;*c!='\0';c++,length++);     //求chars長度
    if(!length){
        T.ch = NULL;
        T.length = 0;
    }else{
        T.ch = (char *)malloc(length*sizeof(char));
        if(!T.ch) exit(ERROR);
        for(int i = 0;i<=length;i++){   //取=號是把 '\0'也放進去
            T.ch[i] = chars[i];
        }
        T.length = length;
    }
    return OK;
}

2.2.2 串比較StrCompare

/**
 * 字串比較
 * @param S
 * @param T
 * @return
 */
int strCompare(HString S,HString T){
    for(int i = 0;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;
}

2.2.3 求串長

/**
 * S長度
 * @param S
 * @return
 */
int strLength(HString &S){
    return S.length;
}

2.2.4 串連線Concat

/**
 * 字串連線
 * @param T
 * @param S1
 * @param S2
 * @return
 */
Status Concat(HString &T,HString S1,HString &S2){
    if(T.ch) free(T.ch); T.ch = NULL;
    T.ch = (char *)malloc((S1.length+S2.length)*sizeof(char));
    if(!T.ch) exit(ERROR);
    for(int i = 0;i<S1.length;i++){
        T.ch[i] = S1.ch[i];
    }
    for(int i = S1.length;i<=S1.length+S2.length;i++){
        T.ch[i] = S2.ch[i-S1.length];
    }
    T.length = S1.length+S2.length;
    return OK;
}

2.2.5 求子串SubString

Status SubString(HString &Sub,HString S,int pos,int len){
    //位置判定
    if(pos<1 || pos>S.length || len <0 || pos+len -1 > S.length) exit(ERROR);
    if(Sub.ch) free(Sub.ch); Sub.ch = NULL;
    if(!len){
        Sub.ch = NULL;
        Sub.length = 0;
    }else{
        Sub.ch = (char *)malloc(len*sizeof(char));
        for(int i = 0;i<len;i++){
            Sub.ch[i] = S.ch[i+ pos-1];
        }
        Sub.length = len;
        Sub.ch[Sub.length -1] = '\0';
    }
    return OK;
}

2.3 塊鏈

塊鏈的操作不如上述兩種結構方便，且佔用儲存量大，這裡不做討論。

3. KMP演算法

子串的定位操作通常稱做串的模式匹配，可以採用暴力尋找，不過這樣的時間複雜度過高，最為經典的演算法是KMP演算法。網上關於該演算法的文章有很多很多，不過目前我所看到最通俗易懂的是這篇，有需要的朋友可以去看看。

4.總結

字串的處理作為一種非常重要的處理方式被廣泛使用，雖然現在最多高階語言都封裝了String類（如Java，C++等），不過作為一種知識的補充也算是非常不錯的。嗯，就這樣吧。