队列的顺序存储的linux下的c实现

顺序存储

头文件 include"seqqueue.h"

seqqueue.h

#include<stdio.h>
#ifndef STATUS_H
#define STATUS_H

#define	TRUE		1			//真 
#define	FALSE		0			//假
#define YES			1			//是
#define NO          0			//否 
#define	OK			1			//通过
#define	ERROR		0			//错误
#define SUCCESS		1			//成功 
#define UNSUCCESS	0			//失败 
#define	INFEASIBLE	-1			//不可行
 
#ifndef _MATH_H_ 				//系统中已有此状态码定义，要避免冲突 
#define	OVERFLOW	-2			//堆栈上溢
#define UNDERFLOW	-3			//堆栈下溢
#endif 
 
#ifndef NULL
#define NULL ((void*)0)
#endif
 
typedef int Status;
#define MAXSIZE 100
typedef int QElemType;
//队列结构体
typedef struct
{
    QElemType *base;
    int front;      //头指针
    int rear;       //尾指针，若队列不为空，指向队列尾元素的下一个位置
}SeQueue;


//基本操作的函数原型说明
//构造一个空队列 
void InitQueue(SeQueue *Q); 
 
//销毁队列，Q不存在 
Status DestoryQueue(SeQueue *Q);
 
//将Q清为空队列
Status ClearQueue(SeQueue *Q);
 
//若Q为空队列，则返回TURE，否则返回FALSE
Status EmptyQueue(SeQueue Q);
 
//若Q为满队列，则返回TRUE，否则返回FALSE-
Status FullQueue(SeQueue Q); 
 
//队列长度
int QueueLength(SeQueue Q);
 
//队列不为空，用e返回队列的头元素，并返回OK，否则返回ERROR
Status GetHead(SeQueue Q, QElemType *e);
 
//掺入元素e为Q的新对尾元素
Status EnQueue(SeQueue *Q, QElemType e);
 
//队列不为空时，删除Q的队列头元素，用e返回其值，并返回OK， 否则返回ERROR
Status DeQueue(SeQueue *Q, QElemType *e);
 
//从对头到对尾依次调用visit函数，失败的话，则操作失败。 
void QueueTraverse(SeQueue Q, Status(*Visit)()); 
#endif

函数库"seqqueue.cpp"

seqqueue.c

/***************************************
author
desc:队列的线性实现函数

**************************************/
#include "sqqueue.h"
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
/*
return:
	OK:构造成功
parm:
	*Q：表示要开辟的空间的队列
desc:
	顺序循环队列的初始化
*/
//构造一个空队列Q 
void InitQueue(SeQueue *Q)
{
	//base指针用于申请指针并存放数据
	Q->base= (QElemType*)malloc(MAXSIZE*sizeof(QElemType));  
	if(!Q->base)
	{
 		exit(OVERFLOW);
	}
	Q->front=Q->rear=0;//队列为空 
}
/*
return:
	TURE:是空队列
	FALSE:非空队列
parm:
	Q：表示判空队列的地址
desc:
	判断队列是否为空
*/
//判断队列是否为空或为满---预留一位来判断是否为空还是满对 
//初始化时，front=rear=0为空，rear=(0+1)%100=1，队列未满
//队列为满时，rear=(99+1)%100=0,此时队列为满队列，不能插入数据 
Status EmptyQueue(SeQueue Q)
{
	if(Q.front==Q.rear)
		return TRUE;
	else
		return FALSE;
}
/*
return:
	TURE:是满队列
	FALSE:非满队列
parm:
	Q：表示要判满队列的地址
desc:
	判断队列是否为满
*/
//判断队列是否为满队列
//预留一位来判断，(rear+1)%MAXSIZE=0为满队 
Status FullQueue(SeQueue Q)
{
	if((Q.rear+1)%MAXSIZE == 0)
		return TRUE;
	else
		return FALSE;
}

/*
return:
	OK：插入成功
parm:
	*Q:顺序循环队列
	e:要进队的元素
desc：
	顺序循环队列的元素进队
*/
//若队列未满，插入元素e为新的队尾元素,若为满队列时溢出 
Status EnQueue(SeQueue *Q, QElemType e)
{
	if(FullQueue(*Q))
		return ERROR;
	Q->base[Q->rear] = e;
	Q->rear++;
	return OK; 
}	
/*
return:
	ERROR:删除失败
	OK:删除成功
parm:
	*Q：顺序循环队列
	e：要出队列的元素
desc：
	顺序循环队列的元素出队
*/
//若队列不为空，删除q的队头元素，并用e返回
//删除对头元素，front+1 
Status DeQueue(SeQueue *Q, QElemType *e)
{
	if (EmptyQueue(*Q))
	{
		return ERROR;
	}
	*e = Q->base[Q->front];
	Q->front++;
	return OK;
}
/*
return:
	OK:清空成功
parm:
	*Q：要清空的队列
desc：
	顺序循环队列置空
*/
//清空队列
Status ClearQueue(SeQueue *Q)
{
	if (EmptyQueue(*Q)){
		return OK; 
	}
	Q->front=Q->rear=0;
	return OK;
} 
/*
return:
	顺序循环队列的长度
parm:
	Q：要求队列长度的队列地址
desc：
	求顺序循环队列的长度；

*/
int QueueLength(SeQueue Q)
{
    return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;
}
/*
return:
	OK:销毁成功
parm:
	*Q：要销毁的队列
desc：
	顺序循环队列的销毁
*/
//销毁队列--释放队列内存 
Status DestoryQueue(SeQueue *Q)
{
	free(Q->base);
	Q->base=NULL;
	Q->front=Q->rear=0;
	return OK;
}
 
/*
return:
	ERROR:获取失败
	OK:获取成功
parm:
	Q：顺序循环队列的地址
	*e:队头元素的值
desc：
	取队列的队头元素
*/
//获取对头元素
Status GetHead(SeQueue Q, QElemType *e)
{
	if (EmptyQueue(Q))
	{
		return ERROR; //判队列是否为空
	}
	*e = Q.base[Q.front];
	return OK;
} 
/*
return:
	OK：打印完成
parm:
	Q：表示要打印元素队列的地址
	*Visit：遍历
desc:
	打印队列元素
*/
void QueueTraverse(SeQueue Q, Status(*Visit)())
{
	int e;
	int i=0;
	for (i=Q.front; i<Q.rear; i++)
	{
		e = Q.base[i];
		printf(" %d", e);
	}
}