数据结构学习：串

数据结构学习：串

串，即字符串（String）是由零个或多个字符组成的有限序列。
一般记为：S = ‘a1 a2 ······an ’ （n ≥0）
其中，S是串名，单引号括起来的字符序列是串的值；ai 可以是字母、数字或其他字符；串中字符的个数n称为串的长度。n = 0时的串称为空串（用∅表示）。

子串： 串中任意个连续的字符组成的子序列。
主串： 包含子串的串。
字符在主串中的位置： 字符在串中的序号。
子串在主串中的位置： 子串的第一个字符在主串中的位置 。
注意：位序从1开始而不是从0开始
M = “”是空串，N=“ ”不是空串，是空格串

串是一种特殊的线性表，数据元素之间呈线性关系
串的数据对象限定为字符集（如中文字符、英文字符、数字字符、标点字符等）
串的基本操作，如增删改查等通常以子串为操作对象

串String的基本操作：

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。

串的比较：
从第一个字符开始往后依次对比，先出现更大字符的串就更大 eg:“abandon” < “aboard”

长串的前缀与短串相同时，长串更大       eg:“abstract” < “abstraction”

只有两个串完全相同时，才相等       eg:“academic”=“academic”

#define MaxLen 255			//预定义最大串长
typedef struct
{
	char ch[MaxLen];
	int length;
}SString;//静态数组实现
// 分配连续的存储空间，每个 char 字符占 1 B
typedef struct
{
	char *ch;	//按串长分配存储区，ch指向串的基地址
	int length;
}HString;//动态数组实现

HString S;
S.ch = (char *)malloc(MaxLen * sizeof(char));
S.length = 0;

// 串的链式存储
typedef struct StringNode
{
	char ch;		//每个节点存储一个字符
	struct StringNode *next;
}StringNode,*String;

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

基于顺序存储基础操作：
SubString(&Sub,S,pos,len)：求子串。用Sub返回串S的第pos个字符起长度为len的子串

// 求子串，用Sub返回串S的第pos个字符起长度为len的子串
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++)//将S中从第pos个字符开始，长为len的字符传给Sub
		Sun.ch[i - pos +1] = S.ch[i];
	Sub.length = len;
	return true;
}

比较操作

// StrCompare(S,T)：比较操作。若S>T，则返回值>0；若S=T，则返回值=0；若S<T，则返回值<0。
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;
}

定位操作

// Index(S,T)：定位操作。若主串S中存在与串T值相同的子串，则返回它在主串S中第一次出现的位置；否则函数值为0。
int Index(SString S,SString T)
{
	int i = 1;
	n = StrLength(S),m = StrLength(T);//获取字符串S和T的长度
	SString Sub;		//定义一个暂存子串
	while(i <= n-m+1)
	{
		SubString(Sub,S,i,m);		//S中第i个字符开始长度为m的字符存储到Sub
		if(StrCompare(Sub,T) != 0)	//将提取到的子串与T比较
			++i;					//不同的话提取子串向后移动
		else
			return i;				//相同的话返回子串的开始位置
	}
	return 0;
}

朴素模式匹配算法：
将主串中所有⻓度为m的⼦串依次与模式串对⽐，直到找到⼀个完全匹配的⼦串，或所有的⼦串都不匹配为⽌。
主串⻓度为n，模式串⻓度为 m
最多对⽐ n-m+1 个⼦串

int Index(SString S,SString T)
{
	int i = 1,j = 1;
	while(i<=S.length && i<=T.length)
	{
		if(S.ch[i] == T.ch[j])//匹配成功向下走
		{
			i++;
			j++;
		}
		else
		{
			i = i - j + 2;//匹配失败重新匹配
			j = 1;
		}
	}
	if(j > T.length)
		return i - T.length;
	else
		return 0;
}

KMP算法
Next数组（手算）
在不匹配的位置前，画一条分界线，然后将模式串一位一位的向后移，并与主串分界线前相应的位数字符相比较，此时j指向哪，next数组的值就是几，如果都不匹配，则为0.

int Index_KMP(SString S,SString T)
{
	int i = 1,j = 1;
	while(i<=S.length && i<=T.length)
	{
		if(j == 0 || S.ch[i] == T.ch[j])//匹配成功向下走
		{
			i++;
			j++;
		}
		else
		{
			j = next[j];
		}
	}
	if(j > T.length)
		return i - T.length;
	else
		return 0;
}

KMP算法，最坏时间复杂度 O(m+n)
其中，求 next 数组时间复杂度 O(m)
模式匹配过程最坏时间复杂度 O(n)