数据结构数组与串

最新推荐文章于 2025-05-28 16:59:46 发布

原创最新推荐文章于 2025-05-28 16:59:46 发布 · 949 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#数据结构

数据结构专栏收录该内容

8 篇文章

订阅专栏

本文深入探讨了串的基本概念、存储结构及其操作算法，包括KMP算法的原理及应用，以及数组和特殊矩阵（如稀疏矩阵）的存储结构和特性。详细解析了字符串匹配算法，并介绍了矩阵的压缩存储方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

知识要点：

串的基本概念、串的存储结构和相关的操作算法；

数组的存储结构，在顺序存储的情况下，数组元素与存储单元的对应关系；

稀疏矩阵的存储结构和特点以及基本操作。

字符串匹配算法(例如KMP算法)。

串的定义：由一个或多个字符组成的有限序列；内字符的个数称之为串的长度，字符个数为0的称之为空串。

串的比较：1）长度相同 2）对应位置上的元素也相同；

重点串的模式匹配算法：

1、暴力匹配算法（BF）：

特点：主串与模式串的指针在发生不匹配时都发生回溯现象（主串回到上一次匹配位置的下一个位置，模式串回到起始位置）；

int BF(char a[],char b[]){
    int i=0,j=0;
    while(i<strlen(a)&&j<strlen(b)){
        if(a[i]==b[j]){
            i++;
            j++;//主串和模式串同时后移
        }
        else{
            i=i-j+1;//主串回溯到上一次位置的下一个比较位置
            j=0;//模式串回溯到起始位置
        }
    }
    if(j>=strlen(b)){
        return i-strlen(b);//返回匹配成功的第一个位置
    }
    return -1;//匹配失败
}

算法时间复杂度：时间复杂度为O(mn)，一般情况下O(m+n)为线性阶；

2、KMP算法（重点掌握next数组的计算）：

特点：主串指针不发生回溯现象，模式串指针回溯

☆☆☆next数组的求解以及KMP算法代码

void getnext(char b[]){          //next数组的计算
	int i=0,j=-1;
	next[0]=-1;                  //初始化next[0]=-1
	while(i<strlen(b)){
		if(j==-1||b[i]==b[j]){
			i++;
			j++;
			next[i]=j;           //i,j指针同时后移，同时修改next数组
		}
		else{
			j=next[j];           //回到上一次最优匹配位置
		}
	}
}
int KMP(char a[],char b[]){
	int i=0,j=0;                 //i与j为主串与模式串的匹配位置
	while(i<strlen(a)&&j<strlen(b)){
		if(j==-1||a[i]==b[j]){
			i++;
			j++;                 //匹配成功主串与模式串同时后移
		}
		else{
			j=next[j];           //回到模式串的最优匹配位置处
		}
	}
	if(j>=strlen(b)){
		return i-strlen(b);      //返回最先发生匹配的位置
	}
	return -1;                   //匹配失败
}

算法解析：（实现模式串的最大移动，减少重复的比较次数）S为主串，T为模式串

假设主串中第i个字符与模式串中的第j个字符发生了失配现象，模式串中的j要回到k位置处重新与主串中第i个位置进行比较

在0--k中必有k-1个字符与主串中的第i位之前的k-1个字符相互匹配，即S[i-k+1,i-1]=T[1,k-1]

在j处发生失配则向前的k-1位必然也与主串相互匹配，即S[i-k+1,i-1]=T[i-j+1,j-1]

有上述两式子得出，模式串回到的位置k与主串无关，且分别为长度相同的前缀串和后缀串（长度为k-1）而模式串所要回到

的位置k即为此串长度+1（即：最大前缀与后缀公共子串长度加一）

举个例子：初始化：next[1]=0；//固定要求

j	1	2	3	4	5	6	7	8
模式串	a	b	a	a	b	c	a	c
next[j]	0	1	1	2	2	3	1	2

next数组第一位置0；//固定要求

第二位无前缀和后缀公共子串记长度为0，则next[2]=1；

第三位无前缀和后缀公共子串记长度为0，则next[3]=1；

第四位有前缀和后缀公共子串a，长度为1，则next[4]=2；

第五位有前缀和后缀公共子串a，长度为1，则next[5]=2；

第六位有前缀和后缀公共子串ab，长度为2，则next[6]=3；

第七位无前缀和后缀公共子串记长度为0，则next[7]=1；

第八位有前缀和后缀公共子串a，长度为1，则next[8]=2；

总结：next数组求解就是找此位置之前的串中最长的匹配前后缀子串，其长度加一就是该位置next数组的值；

3、优化的KMP算法（修正next数组，避免重复匹配）：

特点：主串指针不发生回溯现象，模式串指针回溯，在KML算法中进行了优化处理；

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数组的求解同上；发现在2-4位置都发生了重复匹配的现象，即在2-4任意溢出匹配失败next数组都回到了前一位置

但理论上回到最初的位置重新比较最好，过程中产生了多次的重复比较。

如果下一个位置元素与此位置元素相同则此位置next数组的值与上一个位置的next数组的值相同，反之遵循普通next数组的

求解方式。

☆☆☆nextval数组的求解

void getnextval(char b[]){
	int i=0,j=-1;
	next[0]=-1;
	while(i<strlen(b)){
		if(j==-1||b[i]==b[j]){
			i++;
			j++;                     //指针同时后移
			if(b[i]==b[j]){
				next[i]=next[j];     //如果相同next值相同
			}
			else{
			    next[i]=j;           //如果不同同next数组解法  
			}
		}
		else{
			j=next[j];               //回溯上一个位置
		}
	}
}

数组的存储结构（一般是申请一个固定大小的内存空间，不进行插入或者删除操作）

假设每一个数据元素占用L个存储单元，则二维数组A[0..m-1,0..n-1]中任意一个元素的存储位置为

Loc[a(i,j)]=Loc[a(0,0)]+(n*i+j)*L；（（数单元格数-1）乘空间大小加上起始地址）

3、特殊矩阵的压缩问题（三角矩阵、稀疏矩阵、对称矩阵）

1、对称矩阵（矩阵等于矩阵的转置）对应元素a(i,j)=a(j,i)

若保存全部元素则需要n*n个存储单元，但是由性质得出只需要保存一半，另一半可由性质推出，可将n*n个存储单元压缩至

n*(n+1)/2个存储单元中；

二维矩阵(i,j)和一维数组下标k的对应关系为（下标都从0开始）

按照列优先的标准：k=i(i-1)/2+j-1 （i>=j）；下三角

按照行优先的标准：k=j(j-1)/2+i-1 （i<j）；上三角

2、三角矩阵

上三角矩阵：(i-1)(2n-i+2)/2+j-i；（j<=i）;上三角