队列（二）：顺序存储队列

顺序存储队列需要掌握操作：

• 顺序存储队列存储结构
  

  #define  MAXSIZE 5
  typedef int datatype;
  typedef struct{
  	datatype a[MAXSIZE];
  	int front;
  	int rear;
  }sequence_queue;

• 基本运算实现
  

  void init(sequence_queue *sq);	//队列（顺序存储）初始化	
  int empty(sequence_queue sq);	//队列（顺序存储）是否为空
  void display(sequence_queue sq);	//打印队列（顺序存储）的结点值
  void display_csqstack(sequence_queue sq);	//循环队列
  datatype get(sequence_queue sq);	//取得队列（顺序存储）的队首结点值
  void insert(sequence_queue *sq, datatype x);	//队列（顺序存储）的插入（进队）操作
  void dele(sequence_queue *sq);	//队列（顺序存储）的删除（出队）操作
  void insert_sequence_cqueue(sequence_queue *sq, datatype x);	//循环队列（顺序存储）的插入操作
  void dele_sequence_cqueue(sequence_queue *sq);	//循环队列（顺序存储）的删除操作

  具体函数
  

  #include <stdio.h>
  #include <stdlib.h>
  #include "seqqueue.h"
  /************************************************************************/
  /* 函数功能：队列（顺序存储）初始化										*/
  /* 函数参数：指向sequence_queue类型变量的指针变量sq						*/
  /* 函数返回值：空														*/
  /* 文件名： seqqueue.c，函数名：init()									*/
  /************************************************************************/
  void init(sequence_queue *sq)
  {
  	sq->front=sq->rear=0;
  }
  
  /************************************************************************/
  /* 函数功能：队列（顺序存储）是否为空										*/
  /* 函数参数：指向sequence_queue类型变量sq									*/
  /* 函数返回值：int类型。返回1表示为空，0表示非空							*/
  /* 文件名： seqqueue.c，函数名：empty()									*/
  /************************************************************************/
  int empty(sequence_queue sq)
  {
  	return (sq.front==sq.rear ? 1 : 0);
  }
  
  /************************************************************************/
  /* 函数功能：打印队列（顺序存储）的结点值									*/
  /* 函数参数：指向sequence_queue类型变量sq									*/
  /* 函数返回值：空														*/
  /* 文件名： seqqueue.c，函数名：display()									*/
  /************************************************************************/
  void display(sequence_queue sq)
  {
  	int i;
  	if (empty(sq))
  	{
  		printf("\n顺序队列是空的！");
  	}
  	else
  		for (i=sq.front; i<sq.rear; i++)	//rear指向队尾，下一个存储空间
  		{
  			printf("%5d",sq.a[i]);
  		}
  	printf("\n");
  }
  
  void display_csqstack(sequence_queue sq)	//循环队列
  {
  	int i;
  	if (empty(sq))
  	{
  		printf("\n顺序队列是空的！");
  	}
  	else
  		for (i=sq.front; i!=sq.rear; )	//rear指向队尾，下一个存储空间
  		{
  			printf("%5d",sq.a[i]);
  			i = (i+1) % MAXSIZE;
  		}
  		printf("\n");
  }
  /************************************************************************/
  /* 函数功能：取得队列（顺序存储）的队首结点值								*/
  /* 函数参数：指向sequence_queue类型变量sq									*/
  /* 函数返回值：datatype类型。返回队首结点值								*/
  /* 文件名： seqqueue.c，函数名：get()										*/
  /************************************************************************/
  datatype get(sequence_queue sq)
  {
  	if (empty(sq))
  	{
  		printf("\n顺序队列是空的！无法获得队首结点值！");
  		exit(1);
  	}
  	return sq.a[sq.front];
  }
  
  /************************************************************************/
  /* 函数功能：队列（顺序存储）的插入（进队）操作							*/
  /* 函数参数：指向sequence_queue类型变量的指针变量sq,datatype类型变量x		*/
  /* 函数返回值：空														*/
  /* 文件名： seqqueue.c，函数名：insert()									*/
  /************************************************************************/
  void insert(sequence_queue *sq, datatype x)
  {
  	if (sq->rear == MAXSIZE)
  	{
  		printf("\n顺序队列是满的！");
  		exit(1);
  	}
  	sq->a[sq->rear] = x;
  	sq->rear = sq->rear+1;
  }
  /************************************************************************/
  /* 函数功能：队列（顺序存储）的删除（出队）操作							*/
  /* 函数参数：指向sequence_queue类型变量的指针变量sq						*/
  /* 函数返回值：空														*/
  /* 文件名： seqqueue.c，函数名：dele()*/
  /************************************************************************/
  void dele(sequence_queue *sq)
  {
  	if (empty(*sq))
  	{
  		printf("\n顺序队列是空的！不能做删除操作！");
  		exit(1);
  	}
  	sq->front++;
  }
  
  /************************************************************************/
  /* 函数功能：循环队列（顺序存储）的插入操作*/
  /* 函数参数：指向sequence_queue类型变量的指针变量sq，datatype类型的变量x*/
  /* 函数返回值：空*/
  /* 文件名： seqqueue.c，函数名：insert_sequence_cqueue()*/
  /************************************************************************/
  void insert_sequence_cqueue(sequence_queue *sq, datatype x)
  {
  	if ((sq->rear+1)%MAXSIZE == sq->front)			
  	{
  		printf("\n顺序循环队列是满的！无法进行插入操作！");
  		exit(1);
  	}
  	sq->a[sq->rear]=x;
  	sq->rear = (sq->rear+1)%MAXSIZE;
  }
  
  /************************************************************************/
  /* 函数功能：循环队列（顺序存储）的删除操作*/
  /* 函数参数：指向sequence_queue类型变量的指针变量sq*/
  /* 函数返回值：空*/
  /* 文件名： seqqueue.c，函数名：dele_sequence_cqueue()*/
  /************************************************************************/
  void dele_sequence_cqueue(sequence_queue *sq)
  {
  	if (sq->front == sq->rear)
  	{
  		printf("\n循环队列是空的！无法进行删除操作！");
  		exit(1);
  	}
  	sq->front = (sq->front+1)%MAXSIZE;
  }

• main测试函数
  

  #include <stdio.h>
  #include <stdlib.h>
  #include "seqqueue.h"
  
  void main(void)
  {
  	puts("非循环顺序队列");
  	sequence_queue sq;
  	sequence_queue *p_sq;
  	p_sq = &sq;
  
  	init(p_sq);
  
  	int choosecase = 0;
  	int x;
  	puts("进队请输入0，出队请输入1");
  	while((scanf("%d", &choosecase)) == 1)
  	{
  		switch (choosecase)
  		{
  		case 0:
  			puts("输入进栈元素x");
  			scanf("%d", &x);
  			insert(p_sq, x);
  			display(sq);
  			break;
  		case 1:
  			printf("出栈的元素为%d\n",get(sq));
  			dele(p_sq);
  			display(sq);
  			break;
  		default:
  			break;
  		}
  		puts("进栈请输入0，出栈请输入1");
  	}
  
  	puts("建立一个循环队列");
  	sequence_queue scq;
  	sequence_queue *p_scq;
  	p_scq = &scq;
  
  	init(p_scq);
  
  	puts("进队请输入0，出队请输入1");
  	while((scanf("%d", &choosecase)) == 1)
  	{
  		switch (choosecase)
  		{
  		case 0:
  			puts("输入进栈元素x");
  			scanf("%d", &x);
  			insert_sequence_cqueue(p_scq, x);
  			display_csqstack(scq);
  			break;
  		case 1:
  			printf("出栈的元素为%d\n",get(scq));
  			dele_sequence_cqueue(p_scq);
  			display_csqstack(scq);
  			break;
  		default:
  			break;
  		}
  		puts("进栈请输入0，出栈请输入1");
  	}
  
  	system("pause");
  }