队列和串的KMP匹配算法的实现

循环队列。。。
队列满的条件：
(p->rear+1)%MAXSIZE == p->front;
尾指针加1然后与最大存储值的模
队列长度的条件：
（p->rear-p->front+MAXSIZE)%MAXSIZE;

#include <stdio.h>
#define MAXSIZE 20
typedef int Status;
typedef int Elemtype;
typedef struct
{
	Elemtype data[MAXSIZE];
	int rear;
	int front;
}Squeue;
void init(Squeue* p)
{
	p->front = 0;
	p->rear = 0;
	return;
}
int length(Squeue *p)
{
	return (p->rear - p->front + MAXSIZE) % MAXSIZE;
}
void Insert(Squeue* p, Elemtype e)
{
	if ((p->rear + 1) % MAXSIZE == p->front)
		return;
	p->data[p->rear] = e;
	p->rear = (p->rear + 1) % MAXSIZE;
	return;
}
void Delete(Squeue* p)
{
	if (p->front == p->rear)
		return;
	p->front = (p->front + 1) % MAXSIZE;
	return;
}
void show(Squeue* p)
{
	if (p->front == p->rear)
		return;
	int num = length(p);//循环体内不要使用易变型函数作为条件
	for (int i = 0; i < num; i++)
	{
		printf("%d ", p->front);
		p->front = (p->front + 1) % MAXSIZE;
	}
	return;
}
int main()
{
	Squeue p;
	init(&p);
	for (int i = 0; i < 20; i++)
	{
		Insert(&p, i);
	}
	printf("%d\n", length(&p));
	for (int i = 0; i < 10l; i++)
	{
		Delete(&p);
	}
	printf("%d\n", length(&p));
	show(&p);
	return 0;
}

队列的链式存储结构：

#include <stdio.h>
#include <stdlib.h>
typedef int Status;
typedef int Elemtype;
typedef struct Queue
{
	Elemtype data;
	struct Queue* next;
}Queue;
typedef struct
{
	struct Queue* front;
	struct Queue* rear;
}LinkQueue;
void Init(LinkQueue* p)
{
	p->front = (Queue*)malloc(sizeof(Queue));
	if (!p->front)
		return;
	p->rear = p->front;
	return;
}
int length(LinkQueue p)
{
	return (int)(p.rear - p.front);
}
void Insert(LinkQueue* p, Elemtype e)
{
	Queue* s1 = (Queue*)malloc(sizeof(Queue));
	if (!s1)
		return;
	s1->data = e;
	p->rear->next = s1;
	s1->next = NULL;
	p->rear = s1;
	return;
}
void Delete(LinkQueue* p)
{
	if (p->front == p->rear)
		return;
	Queue *s1;
	s1 = p->front->next;
	Elemtype data = s1->data;
	printf("删除了 %d \n", data);
	p->front->next = s1->next;
	if (p->rear == s1)
		p->front = p->rear;
	free(s1);
	return;
}
void Clear(LinkQueue* p)
{
	if (p->front == p->rear)
		return;
	Queue* s1 = p->front->next;
	Queue* s2;
	int num = 1;
	while (s1)
	{
		s2 = s1->next;
		printf("%d\t", s1->data);
		free(s1);
		s1 = s2;
		if (!(num % 10))
			printf("\n");
		++num;
	}
	p->rear = p->front;
	return;
}
int main()
{
	LinkQueue p,q;
	Init(&p);
	Init(&q);
	for (int i = 0; i < 50; i++)
	{
		Insert(&p, i);
		Insert(&q, i);
	}
	for (int i = 0; i < 7; i++)
	{
		Delete(&p);
	}
	putchar('\n');
	for (int i = 0; i < 9; i++)
	{
		Delete(&q);
	}
	Clear(&p);
	putchar('\n');
	putchar('\n');
	Clear(&q);
}

KMP的初始实现：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int* Next(const char* s)
{
	int i = 1;
	int j = 0;
	int* next = (int*)malloc(sizeof(int) * strlen(s));
	if (!next)
		return 0;
	*(next+1) = 0;
	while (i < strlen(s))
	{
		if (j == 0 || *(s + i - 1) == *(s + j - 1))
		{
			++i;
			++j;
			*(next + i) = j;
		}
		else
		{
			j = *(next + j);
		}
	}
	return next;
}
int Index(const char* s1, const char* s2)
{
	int i = 1;
	int j = 1;
	int* next = Next(s2);
	while (i <= strlen(s1) && j <= strlen(s2))
	{
		if (j == 0 || *(s1 + i - 1) == *(s2 + j - 1))
		{
			++i;
			++j;
		}
		else
		{
			j = *(next + j);
		}
	}
	if (j > strlen(s2))
		return i - strlen(s2);
	else
		return 0;
}
int main()
{
	char ch_1[] = "shijiagang";
	char ch_2[] = "ang";
	printf("%d\n", Index(ch_1, ch_2));
	return 0;
}