【数据结构（四）】串

四. 串

1 串的定义和实现

1.1 串的定义

• 串：零个或多个字符组成的有限序列，如 S = “iPhone 11 Pro Max?”
• 串名：S是串名
• 串的长度：串中字符的个数n
• 空串：n=0时的串
• 子串：串中任意多个连续的字符组成的子序列称为该串的子串
    Eg：“iPhone”，"Prp M"是串S的子串
• 主串：包含子串的串
    Eg：T是子串"iPhone"的主串
• 字符在主串中的位置：某个字符在串中的序号
    Eg：'1’在S中的位置是8（第一次出现）
• 子串在主串中的位置：子串的第一个字符在主串中的位置
    Eg："11 Pro"在S中的位置是8
• 空串 V.S 空格串
    Eg：M = ‘’ 是空串
    Eg：N = ’ ’ 是空格串
• 串 V.S 线性表
    串是特殊的线性表，数据元素之间呈线性关系（逻辑结构相似）
    串的数据对象限定为字符集：中文字符、英文字符、数字字符、标点字符…
    串的基本操作，如增删改除通常以子串为操作对象

1.2 串的基本操作

假设有串 T = '', S = 'iPhone 11 Pro Max?', W = 'Pro'

• StrAssign(&T, chars): 赋值操作，把串T赋值为chars；
• StrCopy(&T, S): 复制操作，把串S复制得到串T
• StrEmpty(S): 判空操作，若S为空串，则返回TRUE，否则返回False；
• StrLength(S): 求串长，返回串S的元素个数；
• ClearString(&S): 清空操作，将S清为空串；
• DestroyString(&S): 销毁串，将串S销毁——回收存储空间；
• Concat(&T, S1, S2): 串联联接，用T返回由S1和S2联接而成的新串———可能会导致存储空间的扩展；
• SubString(&Sub, S, pos, len): 求子串，用Sub返回串S的第pos个字符起长度为len的子串；
• Index(S, T): 定位操作，若主串S中存在与串T值相同的子串，则返回它再主串S中第一次出现的位置，否则函数值为0；
• StrCompare(S, T): 串的比较操作，参照英文词典排序方式；若S > T,返回值>0; S = T,返回值=0 (需要两个串完全相同) ; S < T,返回值<0;

1.3 串的存储结构

1.3.1 定长顺序存储表示

#define MAXLEN 255   //预定义最大串长为255

typedef struct{
    char ch[MAXLEN];   //静态数组实现（定长顺序存储）
                       //每个分量存储一个字符
                       //每个char字符占1B
    int length;        //串的实际长度
}SString;

串长的几种表示法

1. 用一个额外的变量length来存放串的长度（保留ch[0]）
2. 用ch[0]充当length（字符的位序和数组下标相同）
3. 没有length变量，以字符’\0’表示结尾（对应ASCII码的0，求长度需要从头到尾遍历）
4. ch[0]废弃不用，声明int型变量length来存放串的长度（1与2的结合）

基于第4种串长表示法示例

#define MAXLEN 255

typedef struct{
    char ch[MAXLEN];   
    int length;       
}SString;

// 1. 求子串
bool SubString(SString &Sub, SString S, int pos, int len){
    //子串范围越界
    if (pos+len-1 > S.length)
        return false;
    
    for (int i=pos; i<pos+len; i++)
        Sub.cn[i-pos+1] = S.ch[i];
    
    Sub.length = len;

    return true;
}

// 2. 比较两个串的大小
int StrCompare(SString S, SString T){
    for (int i; 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;
}

// 3. 定位操作
int Index(SString S, SString T){
    int i=1;
    n = StrLength(S);
    m = StrLength(T);
    SString sub;        //用于暂存子串

    while(i<=n-m+1){
        SubString(Sub,S,i,m);
        if(StrCompare(Sub,T)!=0)
            ++i;
        else 
            return i;    // 返回子串在主串中的位置
    }
    return 0;            //S中不存在与T相等的子串
}

1.3.2 堆分配存储表示

堆存储结构的特点：仍以一组空间足够大的、地址连续的存储单元依次存放字符序列，但它们的存储空间实在程序执行过程种动态分配的 。

  通常，C语言提供的串类型就是以这种存储方式实现的。由动态分配函数malloc()分配一块实际串长所需要的存储空间（“堆”），如果分配成功，则返回此空间的起始地址，作为串的基址。由free()释放串不再需要的空间。

堆存储结构的优点：堆存储结构既有顺序存储结构的特点，处理（随机取子串）方便，操作中对串长又没有任何限制，更显灵活，因此在串处理的应用程序中常被采用。

//动态数组实现
typedef struct{
    char *ch;           //按串长分配存储区，ch指向串的基地址
    int length;         //串的长度
}HString;

HString S；
S.ch = (char *) malloc(MAXLINE * sizeof(char)); //基地址指针指向连续空间的起始位置
                                                //malloc()需要手动free()
S.length;

1.3.3 链式存储

typedef struct stringNode{
	char ch;				//每个结点存1个字符
	struct StringNode * next;
}StringNode, * String;

问题：存储密度低，每个字符1B，每个指针4B；

解决方案：每一个链表的结点存储多个字符——每个结点称为块——块链结构

typedef struct StringNode{
    char ch[4];           //每个结点存多个个字符
    struct StringNode *next;
}StringNode, * String;

顺序存储和链表存储的优缺点

• 存储分配角度：链式存储的字符串无需占用连续空间，存储空间分配更灵活；
• 操作角度：若要在字符串中插入或删除某些字符，则顺序存储方式需要移动大量字符，而链式存储不用；
• 若要按位序查找字符，则顺序存储支持随机访问，而链式存储只支持顺序访问；

1.4 朴素模式匹配算法

串的模式匹配：在主串中找到与模式串相同的子串，并返回其所在位置。

int Index(SString S, SString T){
	int k = 1;
	int i = k, j =1;
	while(i <= S.length && j <= T.length){
		if(S.ch[i] == T.ch[j]){
			++i;
			++j;
		}
		else{
			k++;
			j = k;
			j = 1;
		}
	}
	if(j > T.length)
		return k;
	else
		return 0;
}

时间复杂度分析
  主串长度为n，模式串长度为m
  最多比较n-m+1个子串
  最坏时间复杂度 = O(nm)
  每个子串都要对比m个字符(对比到最后一个字符才匹配不上)，共要对比n-m+1个子串，复杂度 = O((n-m+1)m) = O(nm - m^2 + m) = O(nm)
  PS:大多数时候，n>>m
  最好时间复杂度 = O(n)
  每个子串的第一个字符就匹配失败，共要对比n-m+1个子串，复杂度 = O(n-m+1) = O(n)

1.5 KMP 算法