数据结构C语言 Part4 串、数组和广义表

最新推荐文章于 2022-11-29 20:21:40 发布

学分

最新推荐文章于 2022-11-29 20:21:40 发布

阅读量383

点赞数 2

分类专栏：数据结构C语言文章标签： c

本文链接：https://blog.csdn.net/qq_42229034/article/details/84200203

版权

数据结构C语言专栏收录该内容

6 篇文章 3 订阅

订阅专栏

首先，我们目前提到的（Part1-Part4）都是线性结构。

这一节，我们主要是要掌握：

1. 了解串的存储方法，理解串的两种模式匹配算法，重点掌握BF算法。

2. 明确数组和广义表这两种数据结构的特点，掌握数组地址计算方法，了解几种特殊矩阵的压缩存储方法。

3.掌握广义表的定义、性质及其GetHead和GetTail的操作。

我们先来看看串（string）：

其参数有串名，串值，串长，主串，字串，串相等，空串，字符位置，字串位置。

//顺序存储
typedef struct
{
    char *ch;
    int length;
}MyString;

//链式，多个字符存在一个结点
#define CHUNKSIZE 80       //可由用户定义的块大小
typedef struct Chunk{
   char  ch[CHUNKSIZE];
   struct Chunk *next;
}Chunk;

typedef struct{
   Chunk *head,*tail;      //串的头指针和尾指针
   int curlen;             //串的当前长度
}LString;

串的模式匹配算法：确定主串中所含子串第一次出现的位置（定位）,方法主要是：

BF算法（又称古典的、经典的、朴素的、穷举的） & KMP算法（特点：速度快）

对于BF算法，将主串的第pos个字符和模式的第一个字符比较，

若相等，继续逐个比较后续字符；若不等，从主串的下一字符起，重新与模式的第一个字符比较。

直到主串的一个连续子串字符序列与模式相等。返回值为S中与T匹配的子序列第一个字符的序号，即匹配成功。否则，匹配失败，我们设返回值 -1。

可见，它的最坏的时间复杂度是O（n*m）这个Scale的。

//暴力检索算法描述
int ViolentMatch(char* s, char* p)
{
	int sLen = strlen(s);
	int pLen = strlen(p);
	int i = 0;
	int j = 0;
	while (i < sLen && j < pLen)
	{
		if (s[i] == p[j])
		{
			//如果当前字符匹配成功（即S[i] == P[j]），则i++，j++    
			i++;
			j++;
		}
		else
		{
			//②如果失配（即S[i]! = P[j]），令i = i - (j - 1)，j = 0    
			i = i - j + 1;
			j = 0;
		}
	}
	//匹配成功，返回模式串p在文本串s中的位置，否则返回-1
	if (j == pLen)
		return i - j;
	else
		return -1;
}

对于KMP（Knuth Morris Pratt所提出的）算法，另一位CSDN的大神写的很好：深度理解KMP链接?。核心是利用已经部分匹配的结果二加快模式串的滑动速度，主串的指针i不必回溯，这样可以提速到O（n+m）。

int KmpSearch(char* s, char* p)
{
	int i = 0;
	int j = 0;
	int sLen = strlen(s);
	int pLen = strlen(p);
	while (i < sLen && j < pLen)
	{
		//①如果j = -1，或者当前字符匹配成功（即S[i] == P[j]），都令i++，j++    
		if (j == -1 || s[i] == p[j])
		{
			i++;
			j++;
		}
		else
		{
			//②如果j != -1，且当前字符匹配失败（即S[i] != P[j]），则令 i 不变，j = next[j]    
			//next[j]即为j所对应的next值      
			j = next[j];
		}
	}
	if (j == pLen)
		return i - j;
	else
		return -1;
}
//优化过后的next 数组求法
void GetNext(char* p,int next[])
{
	int pLen = strlen(p);
	next[0] = -1;
	int k = -1;
	int j = 0;
	while (j < pLen - 1)
	{
		//p[k]表示前缀，p[j]表示后缀
		if (k == -1 || p[j] == p[k]) 
		{
			++k;
			++j;
			next[j] = k;
		}
		else 
		{
			k = next[k];
		}
	}
}

原理图：

next数组和val数组的求法：next数组咱就不说了，可以目测

对于nextval而言，有一个很巧的算法，是我从大神那学来的。

3、next计算过程
不管第一位和第二位是什么，第一位next(1)=0，第二位next(2)=1，这是固定的。

当j=3时，P(j)=C,C之前有”AB”，不存在重复(0位），所以next(3)=0+1=1;
当j=4时，P(j)=D,C之前有”ABC”，不存在重复(0位），所以next(4)=0+1=1;
当j=5时，P(j)=A,C之前有”ABCD”，不存在重复(0位），所以next(5)=0+1=1;
当j=6时，P(j)=B,C之前有”ABCDA”，存在重复”A”(1位），所以next(6)=1+1=2;
当j=7时，P(j)=D,C之前有”ABCDAB”，存在重复”AB”(2位），所以next(7)=2+1=3;

4、nextval=对next的优化
观察第5位”A”,当它不匹配时，按照next行回溯到标号1也为字母A，这时再匹配A是徒劳的，因为已知A不匹配，所以就继续退回到标号1字母A的next(1)=0。为了直接点进行优化，就有了nextval行:

只看前面有重复字母的几位就可以。
j=5，P(5)=A，next(5)=1，P(1)=A=P(5)，所以nextval(5)=next(1)=0;
j=6，P(6)=B，next(6)=2，P(2)=B=P(6)，所以nextval(6)=next(2)=1;
j=7，P(7)=D，next(7)=3，P(3)=C!=P(7)，所以nextval(7)=next(7)=3;

结果：
标号（j）   1   2   3   4   5   6   7
模式串（P）   A   B   C   D   A   B   D
next   0   1   1   1   1   2   3
nextval   0   1   1   1   0   1   3

原文：奈奈酱看nextval 哈哈，开心，谢谢大佬啦

细节我们不一一赘述了，毕竟时间有限。