数据结构笔记——第四章 串

目录

4 串

4.1串的定义和实现

4.1.1 串的定义和基本操作

4.1.2 串的存储结构

4.2 串的模式匹配

4.2.1 串的朴素模式匹配算法

4.2.2 KMP算法

4.2.3 KMP算法的进一步优化

---

4 串

4.1串的定义和实现

4.1.1 串的定义和基本操作

串的定义

串，即字符串（string）是由零个或多个字符组成的有序序列。一般记为：

S = 'abcdef'

其中，S是串名，单引号括起来的字符序列是串的值；abcdef可以是字母，数字或其他字符；串中字符的个数称为串的长度。长度为0时的串称为空串。

子串：串中任意个连续的字符组成的子序列。

主串：包含子串的串。

字符在主串中的位置：字符在串中的序号。

子串在主串中的位置：子串的第一个字符在主串中的位置。

串是一种特殊的线性表，数据元素之间呈线性关系

串的数据对象限定为字符集（如中文字符，英文字符，数字字符，标点字符等）

串的基本操作，如增删改查等通常以子串为操作对象

StrAssign(&T,chars)：赋值操作。把串T赋值为chars

StrCopy(&T,S)：复制操作。由串S复制得到串T

StrEmpty(S)：判空操作。若S为空串，则返回TURE，否则返回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

字符集编码：

任何数据存储到计算机中一定是二进制数。需要确定一个字符和二进制数的对应规则，这就是“编码”

字符集：

英文字符——ASCII字符集

中英文——Unicode字符集

基于同一个字符集，可以有多种编码方案。如UTF-8，UTF-16

4.1.2 串的存储结构

静态数组实现

#define MAXLEN 255//预定义最大串长为255
typedef struct {
	char ch[MAXLEN];//每个分量存储一个字符
	int length;//串的实际长度
}SString;

动态数组实现

#define MAXLEN 255;
typedef struct {
	char* ch;//按串长分配存储区，ch指向串的基地址
	int length;//串的长度
}HString;

void test() {
	HString S;
	S.ch = (char*)malloc(MAXLEN * sizeof(char));
	S.length = 0;
}

串的链式存储

typedef struct StringNode {
	char ch[4];
	struct StringNode* next;
}StringNode, * String;

存储密度由1B提升为4B

基本操作的实现：

求子串

//求子串
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.ch[i - pos + 1] = S.ch[i];
	Sub.length = len;
	return true;
}

比较操作

//比较操作
int StrCompare(SString S, SString T) {
	for (int i = 1; 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;
}

定位操作

//定位操作
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相等的子串
}

4.2 串的模式匹配

4.2.1 串的朴素模式匹配算法

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

//定位操作
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++;
			i = k;
			j = 1;
		}
	}
	if (j > T.length)
		return k;
	else
		return 0;
}

思想：
将主串中与模式串长度相同的子串搞出来，挨个与模式串对比，当子串与模式串某个对应字符不匹配时，就立即放弃当前子串，转而检索下一个子串。

4.2.2 KMP算法

朴素模式匹配算法的缺点：

当某些子串与模式串能部分匹配时，主串的扫描指针i经常回溯，导致时间开销增加。

改进思路：主串指针不回溯，只有模式串指针回溯

KMP算法代码

int Index_KMP(SString S, SString T, int next[]) {
	int i = 1, j = 1;
	while (i <= S.length && j <= T.length) {
		if (j == 0 || S.ch[i] == T.ch[i]) {
			i++;
			j++;//继续比较后续字符
		}
		else
			j = next[j];//字符串向右移动
	}
	if (j > T.length)
		return i - T.length;//匹配成功
	else
		return 0;
}

需要自己根据匹配的子串来创建next数组。

next数组：当模式串的第j个字符匹配失败时，令模式串跳到next[j]再继续匹配

串的前缀：包含第一个字符，且不包含最后一个字符的子串

串的后缀：包含最后一个字符，且不包含第一个字符的子串

当第j个字符匹配失败，由前1~j-1个字符组成的串记为S，则：

next[j]=S的最长相等前后缀长度+1

特别地，next[1]=0

//求模式串T的next数组
void get_next(SString T, int next[]) {
	int i = 1, j = 0;
	next[1] = 0;
	while (i < T.length) {
		if (j == 0 || T.ch[i] == T.ch[j]) {
			i++;
			j++;
			next[i] = j;
		}
		else
			j = next[j];
	}
}

KMP算法修改版

int Index_KMP(SString S, SString T, int next[]) {
	int i = 1, j = 1;
	int next[T.length + 1];
	get_next(T, next);
	while (i <= S.length && j <= T.length) {
		if (j == 0 || S.ch[i] == T.ch[i]) {
			i++;
			j++;//继续比较后续字符
		}
		else
			j = next[j];//字符串向右移动
	}
	if (j > T.length)
		return i - T.length;//匹配成功
	else
		return 0;
}

4.2.3 KMP算法的进一步优化

优化next数组，减少不必要的对比