循環隊列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;
}