循环队列c语言

❶ c语言循环队列

队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接的圆环。

队列是一个特殊的线性表，它的特殊之处在于它只允许表的前面的操作删除，而在表的后面的操作插入，就像堆栈一样，队列100是一个线性表，具有有限的操作。

循环队列就是把向量空间想象成一个首尾相连的环，把这样的向量称为循环向量。存储学位的队列称为循环队列。

在顺序队列中，当指向队列末端的指针到达数组的上界时，不能有更多的队列条目，但数组中仍然有一个空位置。这称为“假溢出”。

(1)循环队列c语言扩展阅读：

判断满队列状态：

1．计数；你通常使用count

Count等于队列的MAXSIZE

2．国旗int

Queueinflag＝1Queueoutflag＝0

= && flag = = 0的前面和后面

3．放一个存储应答单元为空，不存储数据

后面＋1＝前面

注：（不）顺序结构，SeqQueuemyQueue；

❷ C语言二级考试循环链表是循环队列的链式存储结构

循环队列本身是一种顺序存储结构，而循环列表是一种链式存储结构。两者之间是平级关系。

线性链表是线性表的链式存储结构，包括单链表，双链表，循环链表等。

队列的顺序存储结构一般采用循环队列的形式。

循环队列的操作是按数组取摸运算的，所以是顺序存储，而循环链表本身就是收尾相连的，所以循环链表不是循环队列，两种不同的存储结构，虽然实现的功能是一样的，实现循环两种方式 顺序存储就是循环队列，链式存储就是循环链表。

(2)循环队列c语言扩展阅读：

1、比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。

2、逻辑上相邻的节点物理上不必相邻。

3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。

4、查找节点时链式存储要比顺序存储慢。

5、每个节点是由数据域和指针域组成。

6、由于簇是随机分配的，这也使数据删除后覆盖几率降低，恢复可能提高。

❸ 二级c语言，队列、循环队列是什么

队列是一种特殊的线性表，循环队列是将向量空间想象为一个首尾相接的圆环。

1、队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。

2、循环队列是将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列。在顺序队列中，当队尾指针已经到数组的上界，不能再有入队操作，但其实数组中还有空位置，这就叫做“假溢出”，解决假溢出的途径----采用循环队列。

(3)循环队列c语言扩展阅读

判断队列满的情况：

1、count来计数；通常使用count

Count等于队列的MAXSIZE

2、Flag标志 int

入队列 flag=1 出队列flag=0

Front=rear&&flag==0

3、把一个存储单元空出来，不存放数据

Rear+1==front

注意事项：（不要） 顺序结构，SeqQueue myQueue；

❹ 求一个C语言 循环队列的插入 完整程序

（1）编写一个程序，实现顺序环形队列的各种基本运算，并在此基础上设计一个主程序完成如下功能：
（1）初始化队列q；
（2）判断队列q是否非空；
（3）依次进队元素100、909、44、8；
（4）出队一个元素，输出该元素；
（5）输出队列q的元素个数；
（6）依次进队元素-67、55、99、70；
（7）输出队列q的元素个数；
#include<stdio.h>
#include<malloc.h>
#define QUEUE_INIT_SIZE 100
#define QUEUEINCREMENT 10
#define OK 1
#define TURE 1
#define FALSE 0
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
typedef int QElemType;
typedef struct
{
QElemType *base;
int front;
int rear;
}SqQueue;

Status InitQueue(SqQueue &Q)
{
Q.base=(QElemType *)malloc
(QUEUE_INIT_SIZE*sizeof(QElemType));
if(!Q.base)
exit(OVERFLOW);
Q.front=Q.rear=0;
return OK;
}
int QueueNumElem(SqQueue Q)
{
return (Q.rear-Q.front)%QUEUE_INIT_SIZE;
}
Status EnQueue(SqQueue &Q,QElemType e)
{
if((Q.rear+1)%QUEUE_INIT_SIZE==Q.front)
return ERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%QUEUE_INIT_SIZE;

return OK;
}
SqQueue DeQueue(SqQueue Q,int e)
{
int i;
if(Q.front==Q.rear)
printf("队为空!\n");
for(i=e;i<Q.rear;i++)
Q.base[i]=Q.base[i+1];
Q.rear--;
return Q;
}
int main()
{
SqQueue Q,Q1;
static int qele=0;
int i,j=0,k=0,m=0;
static int frontd=Q.front;
i=InitQueue(Q);
if(i==1)
printf("队初始化成功!!\n");
else
printf("队初始化失败!!\n");
if(Q.front!=Q.rear)
printf("队不为空!!\n");
else
printf("队为空L!!\n");
printf("输入数据(END of '9999'):");
scanf("%d",&qele);
while(qele!=9999||Q.rear==Q.front)
{
EnQueue(Q,qele);
scanf("%d",&qele);
}
frontd=Q.front;
while(Q.rear!=Q.front)
{
printf(" %d ",Q.base[Q.front]);
Q.front++;
j++;
}
printf("\n");
Q.front=frontd;
printf("输入要出队的元素:");
scanf("%d",&j);
while(Q.front!=Q.rear)
{
if(Q.base[Q.front]==j)
{
printf("%d\n",Q.base[Q.front]);
Q=DeQueue(Q,Q.front);
m++;
break;
}
Q.front++;
}
Q.front=frontd;
while(Q.front!=Q.rear)
{
printf(" %d ",Q.base[Q.front]);
Q.front++;
}
printf("\n");
Q.front=frontd;
printf("队的长度:%d\n",Q.rear-Q.front);
printf("输入数据(END of '9999'):");
scanf("%d",&qele);
while(qele!=9999||Q.rear==Q.front)
{
EnQueue(Q,qele);
scanf("%d",&qele);
}
Q.front=frontd;
printf("队的长度:%d\n",Q.rear-Q.front);
Q.front=frontd;
printf("出队顺序:");
while(Q.rear!=Q.front)
{
printf(" %d ",Q.base[Q.front]);
Q=DeQueue(Q,Q.front);
m++;
}
printf("end\n");
Q.front=0;
Q.rear=m;
while(Q.rear!=Q.front)
{
free(Q.base);
//Q.base++;
Q.front++;
if(Q.rear-1==Q.front)
printf("队已经释放!\n");
}
return 0;
}

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

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

判断队列已满：

if((front+1)%N==rear%N)//成立则队列已满

判断队列为空

if((rear==front))//成立则队列空

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

//将val入队
que[front++]=val;
front%=N;

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

rear=(rear+1)%N;

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

que[rear];

❻ C语言编程题，实现一个顺序存储的循环队列。

#include<stdio.h>
#include<stdbool.h>
#include<malloc.h>
typedef
int
typedata;
struct
node
{
struct
node
*prev,
*next;
typedata
data;
};
typedef
struct
node
node;
typedef
struct
node*
link;
//
============init_head===============
//
//头节点的初始化
link
init_head(void)
{
link
head
=
(link)malloc(sizeof(node));
if(head
!=
NULL)
{
head->prev
=
head->next
=
head;
}
return
head;
}
//
============newnode
================
//
//创建新节点
link
newnode(typedata
data)
{
link
new
=
(link)malloc(sizeof(node));
if(new
!=
NULL)
{
//前趋指针和后趋指针都指向自己
new->prev
=
new->next
=
new;
new->data
=
data;
}
return
new;
}
//
=================is_empty================
//
bool
is_empty(link
head)
{
//为空时，头节点的前趋指针和后趋指针都指向head（头节点）
if((head->next==head)
&&
(head->prev==head))
return
true;
return
false;
}
//
================insert_tail
==================
//
void
insert_tail(link
head,
link
new)
{
if(is_empty(head))
{
//第一个节点插入
head->next
=
head->prev
=
new;
new->next
=
new->prev
=
head;
return
;
}
//除了第一个节点插入
new->prev
=
head->prev;
new->next
=
head;
new->prev->next
=
new;
new->next->prev
=
new;
}
//
================show
====================
//
void
show(link
head)
{
//为空时，直接返回
if(is_empty(head))
return
;
//遍历整个链
link
tmp
=
head->next;
while(tmp
!=
head)
{
printf("%d\t",
tmp->data);
tmp
=
tmp->next;
}
printf("\n");
}
//
==============insert_opint
===============
//
void
insert_opint(link
end_node,
link
p)
{
p->prev
=
end_node;
p->next
=
end_node->next;
end_node->next->prev
=
p;
end_node->next
=
p;
}
//
================insertion_sort===========
//
//顺序排序
void
insertion_sort(link
head)
{
if(is_empty(head))
return;
//把队列分拆，头节点和第一个节点为一个已排序的队列，
//其他的节点逐个比较已排序队列插
link
p
=
head->next->next;
head->prev->next
=
NULL;
head->next->next
=
head;
head->next->prev
=
head;
head->prev
=
head->next;
while(p
!=
NULL)
{
link
end_node
=
head->prev;
if(p->data
>
end_node->data)
{
link
tmp
=
p;
p
=
p->next;
insert_tail(head,
tmp);
}
else
{
while(end_node!=head
&&
p->data<end_node->data)
end_node
=
end_node->prev;
link
tmp
=
p;
p
=
p->next;
insert_opint(end_node,
tmp);
}
}
}
int
main(void)
{
link
head
=
init_head();
if(head
==
NULL)
{
printf("falure\n");
return
0;
}
typedata
data;
while(1)
{
if(scanf("%d",
&data)
!=
1
)
break;
link
new
=
newnode(data);
if(new
==
NULL)
{
printf("falure\n");
return
0;
}
insert_tail(head,
new);
show(head);
}
printf("the
figure
is:\n");
show(head);
insertion_sort(head);
show(head);
return
0;
}