数据结构---线性表(静态循环队列)

LinkQueue.h

#ifndef __CIRCLE_H__
#define __CIRCLE_H__

//一些库函数的头文件包含
#include <string.h>
#include <ctype.h>
#include <malloc.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <io.h>
#include <math.h>
 
//自定义bool
typedef int Boolean;
 
//定义函数返回状态
typedef int Status;
 
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

#define QUEUE_SIZE 10  //由于为了区别队列空和队列满，实际只使用了QUEUE_SIZE-1个单元

typedef struct cqueue
{
	int *base ;//初始化数组
	int front ; //队列头,数组索引号
	int rear ; //队列尾,数组索引号
}Queue;

/* 初始化 */
Status init(Queue *que);

/* 销毁 */
Status destroy(Queue *que);

/* 重置 */
Status clear(Queue *que);

/* 判空 */
Boolean isEmpty(Queue que);

/* 获取已存元素的数量 */
int listLen(Queue que);

/* 获取队列头元素 */
Status getFront(Queue que, int *front);

/* 入队 */
Status inQue(Queue *que, int elem);

/* 出队 */
Status outQue(Queue *que, int *out_elem);

/* 根据给定关系改变元素的值 */
Status traverse(Queue que, void (*vi)(int *) );

#endif

LinkQueue.c

#include "CircleQueue.h"

/* 初始化 */
Status init(Queue *que)
{
	int *p = (int *)malloc(sizeof(int) * QUEUE_SIZE);
	if(!p)
	{
		printf("动态内存分配失败");
		exit(-1);
	}
	que->base = p;
	que->front = 0;
	que->rear = 0;
	return OK;
}

/* 销毁 */
Status destroy(Queue *que)
{
	if(que->base)
	{
		free(que->base);
	}
	
	que->base = NULL;
	que->front = 0;
	que->rear = 0;
	return OK;
}

/* 重置 */
Status clear(Queue *que)
{
	que->front = 0;
	que->rear = 0;
	return OK;
}

/* 判空 */
Boolean isEmpty(Queue que)
{
	if(que.front == que.rear)
	{
		return TRUE;
	}
	else
	{
		return FALSE;
	}
}

/* 获取已存元素的数量 ,由于是循环的，所以如果队尾到达了数组上线，就会回到数组开始*/
int listLen(Queue que)
{
	return (que.rear - que.front + QUEUE_SIZE) % QUEUE_SIZE;
}

/* 获取队列头元素 */
Status getFront(Queue que, int *front)
{
	if(que.front == que.rear)
	{
		return ERROR;
	}
	*front = que.base[que.front];
	return OK;
}

/* 入队 */
Status inQue(Queue *que, int elem)
{
	//判断队列是否满,为了与队列空区别，少用一个存储单元，来区别队列满
	if((que->rear+1)%QUEUE_SIZE == que->front)
	{
		return ERROR;
	}

	que->base[que->rear] = elem;
	que->rear = (que->rear+1)%QUEUE_SIZE;
	return OK;
}

/* 出队 */
Status outQue(Queue *que, int *out_elem)
{
	//队列空
	if(que->rear == que->front)
	{
		return ERROR;
	}
	*out_elem = que->base[que->front];

	que->front = (que->front+1)%QUEUE_SIZE;
	return OK;
}

/* 根据给定关系改变元素的值 */
Status traverse(Queue que, void (*vi)(int *) )
{
	int i = que.front;
	while(i != que.rear)
	{
		vi(&que.base[i]);
		i = (i+1)%QUEUE_SIZE;
	}
	printf("\n");
	return OK;
}