队列和串

（自复习用，参考严老师的《数据结构c语言版》）

一.队列（FIFO)

• 插入端：rear队尾
• 删除端：front队头
• 双端队列

(一）存储形式

链式存储结构

1. 设置头结点，初始化队列时队头、队尾均指向该头结点。
2. Q.front始终指向头结点，Q.front->next为队首元素。Q.rear为队尾元素。
3. 当删除队首元素时，若队中仅剩一个元素，则应令Q.rear指向头结点。

链式存储结构ADT

根据教材有八个基本操作

//--------单链队列————队列的链式存储结构------
typedef struct QNode{
	QElemType data;
	struct Queue *next;
}QNode,*Queueptr;
typedef struct{
	Queueptr front;	//队列头指针
	Queueptr rear;	//队列尾指针
}LinkQueue;

//-----基本操作--（注意参数）------
Status InitQueue(LinkQueue &Q);//构造空队列
Status DesroyQueue(LinkQueue &Q);//销毁队列
Status GetHead(LinkQueue Q,QElemType &e);//用e返回队列头元素
Status EnQueue(LinkQueue &Q,QElemType e);//进队
Status DeQueue(LinkQueue &Q,QElemType &e);//删除队列头元素，用e返回其值

顺序存储结构——循环队列

即在一定容量的连续空间中实现队列逻辑的线性结构

---

约定

• 初始化建空队列时，front=rear=0。
• 入队时，则存入rear指向位置后，rear++；出队时，front指向位置删除后，front++；
• 则rear尾指针始终指向队列尾元素的下一个位置；front头指针则一直指向队列头元素。

---

于是就会出现假溢出的问题。解决方法：
1. 移动队列
2. 循环队列（顺序存储结构实现队列的常用方式）
即将顺序的存储结构通过臆想使其首尾连接为一个环。则：

	插入元素：Q.rear = （Q.rear+1）%maxlength
	删除元素：Q.front = （Q.front+1)%maxlength

但是如此一来出现的问题：

• 队空、队满均是：（Q.rear+1）%maxlength =Q.front（首尾指针重合）

解决途径：

• 约定队列头指针在尾指针下一位置或计数器（代价相同，牺牲一个存储空间）

(二）应用

1. 约瑟夫出圈问题
   问题描述：n个人围成一圈，从第一个人开始报数， 报到m的人出圈，剩下人继续开始从1报数，直到所有的人都出圈为止。

int Yues(int n,int m)
{
vector<int>   Q(n);
        for(int i=0;i<n;i++)    Q[i]=i;
        while(Q.size()!=1)
        {
            for(int k=0;k<m-1;k++)
            {
                int t=Q[0];
                Q.erase(Q.begin());
                Q.push_back(t);
            }
            Q.erase(Q.begin());
        }
        return Q[0];
}

• 舞伴问题

二.串

(一）知识点

• 串是有零个或多个字符组成的优先序列:
  $s{=}^{\prime }{a}_1{a}_2\dots \dots a_n^{\prime }$ $(n\ge 0)$
• 长度 串中字符的数目。零个字符为空串
• 子串 串中任意连续的字符组成的子序列，包含子串的串为主串
• 必须用一对单引号括起来。

（二）ADT定义

13个基本操作

	1. StrAssign(&T,chars)		//生成值为chars的串T
	2. StrCopy(&T,S)					//由串复制到T
	3. StrEmty(T)
	4. StrCompare(T,S)				//若S>T返回值>0,相等返回0，否则返回-1
	5. StrLength(T)
	6. ClearString(&T)				//将S清为空串
	7. Concat(&T,S1,S2)			//返回S1,S2拼接而成的新串
	8. SubString(&Sub,S,pos,len)		//用Sub返回S中从pos起长度为len的子串
	9. Index(S,T,pos)			//若主串S中存在和串T相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置；否则返回0；
	**10. Replace(&S,T,V)	//用V替换主串S中出现的所有与T相等的不重叠的子串。
	**11. StrInsert(&S,pos,T)	//在串S的第pos个字符之前插入T
	**12. StrDelete(&S,pos,len)	//删除S中第pos个字符起长度为len的子串
	13. DestroySring(&S)

（三）实现方式

定长顺序存储表示

# define MSXSTRING 25
typedef unsigned char SString[MAXSTRING+1];	//0号单元存放串的长度

• 超过预定义长度的串值被“截断”
• 或定义为结尾加结束字符‘\0’；而不用0号单元存储长度。
• 约定操作中出现串值序列的长度超过上界时用截尾法

堆分配存储表示

• 利用动态分配函数：malloc(),realloc(),free()
• 堆分配存储：存储效率高，操作效率低（在链串中为了提高存储密度，应该增大结点的大小）（堆分配存储）

串的块链存储表示

• 一字一结：存储效率低，操作效率高
• 对比其它两种存储结构不如其灵活，占用存储量大且操作复杂、

（四）算法

模式匹配

• 朴素模式匹配算法（Brute-Force暴力算法）O（m*n）

• KMP算法（m+n)

  1.主串不回溯，模式向右滑动尽可能远的一段距离（next[j]）后继续进行比较.
  2.核心思想：利用已经得到的部分匹配信息来进行后面的匹配过程（包含于模式块的next赋值及匹配两个过程中）
  3.next函数（不同算法定义略有差别，此处遵循定义如下）：
  	（1）next[0]=-1：任何串的第一个字符的模式值规定为-1；
  	（2）next[j]=-1,模式串中t[j]与首字符相同且前k个字符与开头k个字符不相等（或相等但t[k]=t[j])（即首字母不会为0，其他值为0的时候它为-1）
  	（3）next[j]=k,模式串中t[j]前k个字符与开头k个字符相等，且t[j]!=t[k],1<=k<j；
  	（4）next[j]=0(除1，2，3，代码实现中令next[j]=next[k])
  

void GetNext(char *T, int next[])
{
	int k = -1, j = 0;
	next[0] = -1;//首字母为-1
	while (T[j] != '\0')
	{
		if (k == -1 || T[j] == T[k])//只有字母相等时或k=-1时指标++
		{
			++j;
			++k;
			if (T[j] != T[k])//不相等时，先给next[j]赋值，再在下一次循环中给k赋值为next[k]，因为可能需要回退好多次，放在判断相等的条件外。
			{
				next[j] = k;
			}
			else
				next[j] = next[k];//相等时赋此以防右滑后无效的比较一次（两个相等都和主串不一样还比啥，直接上上一个，客观上都是0或-1（首））
		}
		else
			k = next[k];
	}
}
int KMP(char *s, char *t, int next[])
{
	int index = 0, i = 0;
	int j = 0;
	if (!s || !t || t[0] == '\0' || s[0] == '\0')//判断是否为空指针/空串
		return -1;
	while (t[j] != '\0'&&s[i] != '\0')//当都没到串尾时
	{
		if (s[i] == t[j])
		{
			++i;
			++j;
		}
		else//不相等则需要判断怎么滑了
		{
			index += j - next[j];//上述对比中比较了（j+1）个，头在j-next[j]处。
			if (next[j] != -1)
			{
				j = next[j];
			}
			else
			{
				j = 0;
				++i;//原本的i和j[-1]对应，++i和j[0]重新比较。
			}
		}
	}
	return((t[j] == '\0') ? index : -1);//匹配失败则t[j]没到最后。
}