队列-静态循环队列

静态循环队列，队列拿出来了一个存储位置不存放数据来区分 栈空和栈满

，因为循环，所以移动的时候，都要有模运算。

队列结构体含有3种类型。int front，栈头索引。int rear 栈尾索引。 int* pBase 指向一个数组（数组大小在初始化的时候手动分配）（或者 int pBase[5]）这样是在栈内存就分配好了。

typedef struct Queue
{
	int * pBase;  //在初始化的时候动态创建数组
	int front;
	int rear;
} Queue,*pQueue;

 pBase=(int*) malloc(sizeof(int)*6) //6个int型数组

代码如下：

#include <iostream>
using namespace std;

typedef struct Queue
{
	int* pBase;  //在初始化的时候动态创建数组
	int front;
	int rear;
} Queue;
void init(Queue* );
bool enqueue(Queue*,int);
void traverse(Queue*);
bool full_queue(Queue*);
bool out_queue(Queue*,int*);

int main()
{
	int val;
	Queue Q;
	init(&Q);
	enqueue(&Q,11);
	enqueue(&Q,22);
	enqueue(&Q,33);
	enqueue(&Q,44);
	enqueue(&Q,55);
	enqueue(&Q,66);
	enqueue(&Q,77);
	traverse(&Q); // 11 22 33 44 55 
	out_queue(&Q,&val); 
	cout<<"删除的元素" << val <<endl; //55
	traverse(&Q); //11 22 33 44

	return 0;
}

void init(Queue* p_Q)
{
	p_Q->pBase=(int*)malloc(sizeof(int)*6);
	p_Q->front=0;
	p_Q->rear=0;
}
bool full_queue(Queue* p_Q)
{
	if ((p_Q->rear+1)%6==p_Q->front)
	{
		return true;
	}
	else 
		return false;
}
bool enqueue(Queue* p_Q,int val)
{
	if (full_queue(p_Q))
	{
		return false;
	}
	p_Q->pBase[p_Q->rear]=val;
	p_Q->rear=(p_Q->rear+1)%6;
	return true;
}

void traverse(Queue* p_Q)
{
	int i=p_Q->front;
	for (;i!=p_Q->rear;(i=i+1)%6)
	{
		cout << p_Q->pBase[i] <<" ";
	}
}
bool emput_queue(Queue* p_Q)
{
	if (p_Q->front==p_Q->rear)
	{
		return true;
	}else
		return false;
}
bool out_queue(Queue* p_Q,int* pval)
{
	if (emput_queue(p_Q))
	{
		return false;
	}
	else
	{
		*pval=p_Q->pBase[p_Q->front];
		p_Q->front=(p_Q->front+1)%6;
	}
}

上述的int类型数组是在堆内存动态分配的。

也可在栈内存分配

typedef struct Queue
{
	int pBase[6];  //在初始化的时候动态创建数组
	int front;
	int rear;
} Queue;

这时候初始化函数为

void init(Queue* p_Q)
{
	p_Q->front=0;
	p_Q->rear=0;
}