環形隊列c語言
A. c語言環形隊列 鏈表 和數組的區別
隊列先進先出 適合用於排序
鏈表適合用於存儲
C的數組就是指針 適合用於查詢
B. C語言中隊列怎樣創建
隊列是一種特殊的鏈表,在你寫GET和PUT方法時只需要返回鏈表的第一個值,把你要輸的值放鏈表的最後就是隊列了!!!
C. C語言中循環隊列的隊滿和隊空的判斷條件各是什麼有什麼不同
隊空時： Q.front == Q.rear;
隊滿時： Q.front == (Q.rear + 1) % MAXSIZE;
front指向隊首元素，rear指向隊尾元素的下一個元素。
maxsize是隊列長度。
(3)環形隊列c語言擴展閱讀：
實現的代碼：
#include <stdio.h>
#include <malloc.h>
#define MAXSIZE 100 //最大隊列長度
#define OK 1
#define ERROR 0
typedef int ElemType;
typedef int Status;
typedef struct {
ElemType *base; //隊列空間
int front; //隊頭指針
int rear; //隊尾指針，若隊尾不為空，則指向隊尾元素的下一個位置
}SqQueue;
//初始化循環隊列
Status initQueue(SqQueue &Q) {
Q.base = (ElemType *) malloc(MAXSIZE * sizeof(ElemType)); //申請空間
Q.front = Q.rear = 0; //隊空
return OK;
}
//入隊
Status enQueue(SqQueue &Q, ElemType e) {
if ((Q.rear + 1) % MAXSIZE == Q.front) return ERROR; //隊滿，無法添加
Q.base[Q.rear] = e; //插入元素
Q.rear = (Q.rear + 1) % MAXSIZE; //隊尾指針+1
return OK;
}
//出隊
Status deQueue(SqQueue &Q, ElemType &e) {
if (Q.front == Q.rear) return ERROR; //隊空，無法刪除
e = Q.base[Q.front]
Q.front = (Q.front + 1) % MAXSIZE; //隊頭指針+1
return OK;
}
//返回隊列長度
Status length(SqQueue &Q) {
return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;
}
D. 用c語言實現刪除環形隊列第k個元素
樓主你好。
你所指的環形隊列在刪除元素的時候有什麼特殊要求么？比如繞一周就不再刪除？
還是說環形隊列一定可以找到第k個元素？
我現在假設環形隊列一定可以找到第k個元素，如下：
void DeleteIndexedNode(DList* thiz, int k){//刪除第k個元素
DNode* iter=thiz->first;
DNode* pIter;
int index;//假設隊列從1開始編號
if(!iter)//隊列為空，取消刪除
return;
//若想繞一周不再刪除，上面可以if(!iter || k > thiz->length) return;//若隊列為空或超過一周，取消刪除
if( k == 1){//若刪除首個節點
thiz->first = iter->next;
thiz->last->next = thiz->first;//DList結構若不是雙向鏈表，應該有一個last指針，提高效率
DestroyDNode(iter);//這個是你自己定製的DNode的析構函數
return;
}
//若刪除其他節點
do{
pIter = iter;//pIter指向iter前一個節點，用於幫助析構。
iter = iter->next;
index++;
}while(index < k) ;//因為是環形隊列，肯定可以找到第k個元素，而且iter不會為NULL
pIter->next = iter->next;//iter的前一個節點的next繞過iter
DestroyDNode(iter);//這個是你自己定製的DNode的析構函數
return;
}
E. 求一個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;
}
F. c語言實現 一個具有MaxLen個單元的環形隊列,設計求其中共有多少個元素
#include<iostream.h>
#include<stdlib.h>
#define QElemType int
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define MAXQSIZE 100
typedef struct{
QElemType *base;
int front;
int rear;
int length;
int maxsize;
}SqQueue;
int InitQueue(SqQueue &Q,int n)
{
Q.base=new QElemType[n];
if(Q.base==0)return 0;
Q.rear=Q.front=0;
Q.length=0;
Q.maxsize=n;
return 1;
}//構造空隊列Q
int QueueLength (SqQueue Q){
return (Q.rear -Q.front +MAXQSIZE) % MAXQSIZE;
}//返回Q的元素個數，即隊列的長度
int EnQueue(SqQueue &Q,QElemType e)
{
if(Q.length==Q.maxsize)return 0;
Q.base[Q.rear]=e;
Q.rear=(Q.rear++)%Q.maxsize ;
Q.length++;
return 1;
}//插入元素e為Q的新的隊尾元素
int DeQueue(SqQueue &Q,QElemType &e)
{
if(Q.length==0)return 0;
e=Q.base[Q.front];
Q.front=(Q.front+1)%Q.maxsize;
Q.length--;
return 1;
}//刪除Q的隊頭元素，用e返回其值
int GetHead(SqQueue Q,QElemType &e)
{
if(Q.length==0)return 0;
e=Q.base[Q.front];
return 1;
}
bool Empty(SqQueue Q)
{
if(Q.length==0)return true;
return false;
}
void print(SqQueue Q)
{
int k=Q.front;
for(int i=1;i<=Q.length;i++)
{
cout<<Q.base[k]<<" ";
k=(k+1)%Q.maxsize;
}
cout<<endl;
}
void main()
{
SqQueue Q;
QElemType e,i;
InitQueue(Q,10);
cout<<"1:輸入一隊列"<<endl;
cout<<"2:隊列的刪除"<<endl;
cout<<"3:隊列的插入"<<endl;
cout<<"4:返回元素個數"<<endl;
cout<<"5:退出"<<endl;
int s;
cin>>s;
while(s!=5){
switch (s){
case 1:
cout<<"輸入6個元素組成隊列: ";
for(i=0;i<6;i++)
{
cin>>e;
EnQueue (Q,e);
}
print(Q);
break;
case 2:
if(Empty(Q))
cout<<"要刪除的元素不存在";
else
{
GetHead( Q,e);
cout<<"要刪除的元素為 :"<<e<<endl;
DeQueue(Q,e);
cout<<"元素刪除後的隊列為: ";
print(Q);
}
break;
case 3:
cout<<"輸入准備插入的元素: ";
cin>>e;
EnQueue(Q,e);
cout<<"插入後的隊列為： ";
print(Q); break;
case 4:
cout<<"元素個數為:";
cout<<QueueLength ( Q);
cout<<endl; break;
case 5:
cout<<"退出程序";
//return;
default: cout<<"輸入錯誤，請重新輸入!"<<endl;
}
cout<<endl<<"請繼續選擇:"<<endl;
cin>>s;
}
}
G. 對於一個具有MaxLen個單元的環形隊列,求其中共有多少個元素.用C語言實現.
參看下面代碼
program ex5_2(input,output);
const max=1000;
type recordtype=record price,content:real end;
var i,j,n,point,tail:longint;
content,change,distance2,<WBR>money,use:real;
price,distance,consume:array[<WBR>0..max] of real;
oil:array [0..max] of recordtype;
begin
write('Input DI,C,D2,P:'); readln(distance[0],content,<WBR>distance2,price[0]);
write('Input N:'); readln(n); distance[n+1]:=distance[0];
for i:=1 to n do
begin
write('Input D[',i,'],','P[',i,']:');
readln(distance[i],price[i])
end;
distance[0]:=0;
for i:=n downto 0 do consume[i]:=(distance[i+1]-<WBR>distance[i])/distance2;
for i:=0 to n do
if consume[i]>content then
begin writeln('No Solution'); halt end;
money:=0; tail:=1; change:=0;
oil[tail].price:=price[0]*2; oil[tail].content:=content;
for i:=0 to n do
begin
point:=tail;
while (point>=1) and (oil[point].price>=price[i]) do
begin
change:=change+oil[point].<WBR>content;
point:=point-1
end;
tail:=point+1;
oil[tail].price:=price[i];
oil[tail].content:=change;
use:=consume[i]; point:=1;
while (use>1e-6) and (point=oil[point].content
then begin use:=use-oil[point].content;
money:=money+oil[point].<WBR>content*oil[point].price;
point:=point+1 end
else begin oil[point].content:=oil[point]<WBR>.content-use;
money:=money+use*oil[point].<WBR>price;
use:=0 end;
for j:=point to tail do oil[j-point+1]:=oil[j];
tail:=tail-point+1;
change:=consume[i]
end;
writeln(money:0:2)
end.
H. 什麼是環形隊列，採用什麼方法實現環形隊列
在用數組表示隊列時把數組看成是一個環形的，即令數組中的第一個元素緊跟在最末一個單元之後就形成了一個環形隊列。
通常採用邏輯上求余數的方法來實現環形隊列，假設數組的大小為n,當元素下標i增1時採用i=(i+1)％n來實現。
(8)環形隊列c語言擴展閱讀：
隊列的特點是先進先出，或者後進後出。環狀隊列在數據結構里稱為循環隊列。也就是把隊列的尾和頭接在一起形成一個環，這樣當發生假溢出時，尾指針可以跳到數組的開始，重復利用那些已經從隊列里刪掉的存儲單元。
可以用數組和兩個指針（頭指針和尾指針，但數據類型可以為整形，只是表示指向的含義）組成一個結構體來實現隊列。
環形隊列是一個可以實現所有結構體且可以提高個人對指針的了解的一個程序。
程序是用codeblock寫的，中間碰到了一個又一個的問題，都最終解決了。這個結構可以作為所有結構體的實現的一個模式。寫寫這些程序可以不斷讓自己更加深入認識指針，更加熟悉指針的各種使用。
I. C語言中，隊列是什麼意思，有什麼用途
隊列是一種特殊的線性表。
隊列一種可以實現「先進先出」的存儲結構，即「一端入，一端出」，隊首(front)出隊，隊尾(rear)入隊，若front指向隊首，則rear指向隊尾最後一個有效元素的下一個元素；若rear指向隊尾，則front指向隊首第一個有效元素的下一個元素。
隊列特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。
(9)環形隊列c語言擴展閱讀
循環隊列各個參數的含義
1、隊列初始化front和rear的值都是零,初始化時隊列就是空的。
2、隊列非空front代表隊列的第一個元素rear代表了最後一個有效元素的下一個元素。
3、隊列空front和rear的值相等，但是不一定是零。
J. 用C語言實現刪除環形隊列第K個元素
樓主你好。
我現在假設環形隊列一定可以找到第k個元素，如下：
void DeleteIndexedNode(DList* thiz, int k){//刪除第k個元素
DNode* iter=thiz->first;
DNode* pIter;
int index;//假設隊列從1開始編號
if(!iter)//隊列為空，取消刪除
return;
//若想繞一周不再刪除，上面可以if(!iter || k > thiz->length) return;//若隊列為空或超過一周，取消刪除
if( k == 1){//若刪除首個節點
thiz->first = iter->next;
thiz->last->next = thiz->first;//DList結構若不是雙向鏈表，應該有一個last指針，提高效率
DestroyDNode(iter);//這個是你自己定製的DNode的析構函數
return;
}
//若刪除其他節點
do{
pIter = iter;//pIter指向iter前一個節點，用於幫助析構。
iter = iter->next;
index++;
}while(index < k) ;//因為是環形隊列，肯定可以找到第k個元素，而且iter不會為NULL
pIter->next = iter->next;//iter的前一個節點的next繞過iter
DestroyDNode(iter);//這個是你自己定製的DNode的析構函數
return;
}
以上函數可以實現刪除第K個元素，有什麼問題可以再問我。