循环队列出队（数据的循环队列是什么）

本文目录

• 数据的循环队列是什么
• 循环队列的入队和出队
• 在循环队列中怎样实现入队和出队操作 数据结构 C语言
• 试写出循环队列出队、入队的算法（用C语言给出主要部分即可）
• 在循环队列中入队、出队操作的过程
• 采用顺序存储如何实现循环队列的初始化、入队、出队操作
• C语言用数组实现循环队列的入队出队
• 循环队列中入队与出队算法
• 编程：循环队列的入队、出队（要有main函数）

数据的循环队列是什么

充分利用数组空间，克服顺序队列的“假上溢”现象，将为队列分配的数组空间看成为一个首尾相接的圆环，并称这种队列为循环队列。

在循环队列中进行出队、入队操作时，队首、队尾指针仍要加1，朝前移动。只不过当队首、队尾指针指向数组上界（MAXSIZE－1）时，其加1操作的结果是指向数组的下界0，循环队列不会上溢。同样是约定在非空循环队列里，队首指针始终指向队头元素，队尾指针始终指向队尾元素的下一个位置。因此，真正实用的顺序队列是循环队列。

循环队列的入队和出队

例、
用带头结点的单循环链表表示一个队列，且只设一个指向队尾元素的指针p，试分别写出入队和出队算法。

入队算法
typedef struct node
{
《datatype》 data;
struct node *next;
}Qnode;
Qnode * in_queue ( Qnode *p, 《datatype》 x )
{
Qnode * q;
q = (Qnode*)malloc( sizeof(Qnode) ); /*取得一个新结点*/
q-》data = x; /*将x置入新结点数据域中*/
q-》next = p-》next;
p-》next = q; /*将新结点插在原队列之后*/
p = q; /*p指向新的队尾结点*/
return ( p );
}

出队算法
Qnode * out_queue ( Qnode *p, 《datatype》 *x )
{
Qnode * front, *q;
if ( p-》next == p ) /*空队列*/
exit;
front = p-》next; /*front指向表头结点*/
q = front-》next; /*q指向队头元素结点*/
*x = q-》data;
front-》next = q-》next; /*删除队头元素结点*/
free ( q );
if ( front-》next == front ) /*原队列只有一个元素时*/
p = front;
return ( p );
}

在循环队列中怎样实现入队和出队操作 数据结构 C语言

入队操作
功能：将元素 x 插入到Q的队尾。
算法：Status EnQueue(SqQueue &Q, QElemType e) {
if ((Q.rear+1) % MaxQsize == Q.front) return ERROR; // 队列满
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1) % MaxQsize;
return OK;
}
出队操作
功能：删除Q的队头元素，并返回其值。
算法： Status DeQueue(SqQueue &Q, QElemType &e) {
if (Q.front == Q. rear) return ERROR; // 队列空
e = Q.base[Q.front];
Q.front=(Q.front+1) % MaxQsize;
return OK;
}

试写出循环队列出队、入队的算法（用C语言给出主要部分即可）

#define Max 300
typedef struct
{
int tail,head;
int a[Max];
}queue;
void enqueue(int key,queue&q)
{
q.a[q.tail]=key;
q.tail=(q.tail+1)%Max;
}
int dequeue(queue&q)
{
int key;
key=q.a[q.head];
q.head=(q.head+1)%Max;
return key;
}
用了c++引用。。。。。。没有入队前的判断是否满了以及出队前判断是否为空，这个你应该懂的

在循环队列中入队、出队操作的过程

入队：
1、新建一个变量p，指定内存空间；
2、将变量p的next指针指向队头head；
3、将队尾变量的next指针指向变量p；
4、将变量p变为队尾（或队头）；
5、具体如下：
new(p);
p^.data:=****(自选数据)
p^.next:=head;
tail^.next:=p;
tail:=tail^.next;(或head:=p;)

出队：单项循环队列中需要搜索出队变量的前缀（或后缀），双向循环队列不需，设该出队变量为x；前缀为p，后缀o为q；
1、将前缀的next（或right）指针指向后缀；
2、（单项循环队列不要此项）将后缀的last（或left）指针指向前缀；
3、若从队头或队尾出队则要调整队头变量head或队尾变量tail；
4、释放出队的变量；
5、具体如下：
p^.next:=q;
q^.last:=p;
head:=q;(或tail:=p;)
dispose(x);

采用顺序存储如何实现循环队列的初始化、入队、出队操作

#include《stdio.h》
#define MAXSIZE 100
typedef struct seqqueue
{
int data[MAXSIZE];
int front;
int rear;
}seqqueue;

void Initseqqueue(seqqueue &q) //循环队列初始化
{
q.front =q.rear=0;
printf(“初始化成功！\n“);
}

int enqueue(seqqueue &q,int e) //数据元素e入队列
{
if((q.rear+1)%MAXSIZE==q.front)
{
printf(“循环队列满!\n“);
return 0;
}
else
{
q.data[q.rear]=e;
q.rear=(q.rear+1)%MAXSIZE;
printf(“%d入队列成功!\n“,e);
return 1;
}
}

int isemptyqueue(seqqueue &q) //判断循环队列是否为空
{
if(q.rear ==q.front )
{
printf(“ 空队列!\n“);
return 1;
}
else
{
printf(“非空队列!\n“);
return 0;
}
}
int dequeue(seqqueue &q,int &e) //数据元素出队列，出队列元素暂存储于e中
{
if(!isemptyqueue(q))
{
e=q.data [q.front ];
q.front =(q.front +1)%MAXSIZE;
printf(“出队列成功!\n“);
return 1;
}
else
{
printf(“出队列失败!\n“);
return 0;
}
}
void main()
{
int x=0;
seqqueue qa;
Initseqqueue(qa);
isemptyqueue(qa);
dequeue(qa,x);
enqueue(qa,25);
isemptyqueue(qa);
dequeue(qa,x);
}

C语言用数组实现循环队列的入队出队

//定义一个int型数组que,长度为N(常量切大于2).
int que[N];
int rear=0,front=0; //队尾 队头

判断队列已满：

判断队列为空

入队(一般在入队前判断队列是否已满)

出队(一般在出队前判断队列是否为空)

下一个要出队的元素(一般先判断是否为空)

循环队列中入队与出队算法

如果循环队列每个元素有两个指针，一个指向其前面的元素pPre，一个指向后面的元素pNext，出对和入队就是修改一下指针啊。
比如指向要出队的元素的指针是 pDel,那么出队就应该是：
pDel-》pPre-》pNext = pDel-》pNext;
pDel-》pNext-》pPre = pDel-》pPre;

如果循环队列每个元素只有一个指向其后元素的指针pNext，那么需要遍历整个队列，找到要出队元素的前一个元素，然后就和上面的算法差不多了。

如果经常要进行出队操作，在设计数据结构的时候还是建议每个元素使用两个指针。

编程：循环队列的入队、出队（要有main函数）

#include《iostream》
using namespace std;
template 《typename T》
struct Node
{
T data;
struct Node *next;
};
template 《typename DATA》
class cycle_queue
{
public:
Node《DATA》 *head;//队列头，不保存数据
Node《DATA》 *end;//队列尾，不保存数据
unsigned int size;
cycle_queue()
{
head=new Node《DATA》();
end=new Node《DATA》();
size=0;
}
void push_back(DATA d)//入队列
{
Node《DATA》 *tmp;
tmp=new Node《DATA》;
tmp-》data=d;
if(size==0)
{
head-》next=tmp;
end-》next=tmp;
tmp-》next=tmp;
}
else
{
end-》next-》next=tmp;
end-》next=tmp;
tmp-》next=head-》next;
}
++size;
}
DATA front()//取队头元素，不负责检查是否为空
{
DATA re;
if(size!=0)
re=head-》next-》data;
return re;
}
void pop()//队头元素出列，不负责检查是否为空
{

if(size!=0)
{
Node《DATA》 *tmp;
tmp=head-》next;
head-》next=head-》next-》next;
end-》next-》next=head-》next;
delete tmp;
--size;
}
}
bool empty()//队列判空
{return size==0;}
};
int main()
{
int a={10,9,8,7,6,5,4,3,2,1};
class cycle_queue《int》 cq;
short i;
for(i=0;i!=10;++i)
cq.push_back(a[i]);
cout《《“**************“《《endl;
while(!cq.empty())
{
cout《《cq.front()《《“ “;
cq.pop();
}
cin》》i;
return 0;
}