隊列數組c語言實現

1. c語言，請用數組作個循環隊列

a#include "Stdio.h"
#include <stdlib.h>
#include "Conio.h"
#include "malloc.h"
#define TRUE 1
#define FALSE 0
#define INFEASIBLE 1
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define MAXQSEZE 100 /*最大隊列長度*/
typedef int QElemType;
typedef int Status;
typedef struct{
QElemType *base; /*初始化的動態分配存儲空間*/
int front; /*頭指針，若隊列不空，指向隊列頭元素*/
int rear; /*尾指針，若隊列不空，指向隊列尾元素的下一位置*/
}SqQueue;
Status Queuelength(SqQueue *Q){
/*構造一個空的循環隊列*/
Q->base=(QElemType *)malloc(MAXQSEZE*sizeof(SqQueue));
if(!Q->base) exit(OVERFLOW); /*存儲分配失敗*/
Q->front=Q->rear=0;
return OK;
}
Status EnQueue(SqQueue *Q,QElemType e){
/*插入元素e為Q的新的隊尾元素*/
if((Q->rear+1)%MAXQSEZE==Q->front) return ERROR;/*隊列滿*/
Q->base[Q->rear]=e;
Q->rear=(Q->rear+1)%MAXQSEZE;
return OK;
}
Status DeQueue(SqQueue *Q,QElemType *e){
/*若隊列不空，則刪除Q的隊頭元素，用e返回其值*/
/*否則返回ERROR*/
if(Q->front==Q->rear) return ERROR;
*e=Q->base[Q->front];
Q->front=(Q->front+1)%MAXQSEZE;
return OK;
}
Status GetHead(SqQueue *Q,QElemType *e){
/*隊列不為空用e返回Q的頭元素，並返回OK，否則返回ERROR*/
if(Q->front==Q->rear) return ERROR;
*e=Q->base[Q->front]; return OK;
}
Status QueueEmpty(SqQueue *Q){
/*隊列為空時返回OK否則返回FALSE*/
if(Q->front==Q->rear) return OK;
return FALSE;
}
void yanghuiTriangle(int n){
/*列印輸出楊輝三角的錢n(n>0)行*/
SqQueue Q;
char ch=' ';
int i,k;
QElemType s,e;
FILE *fq;
if((fq=fopen("output.txt","w"))==NULL){ /*打開寫入文件*/
printf("error on open\n");
exit (1);
}
Queuelength(&Q); /*創建空的隊列*/
for(i=1;i<n;i++)
{ printf(" "); fputc(ch,fq);} /*輸出n個空格以保持三角形的隊形*/
printf("1\n");
fprintf(fq,"%d\n",1);
EnQueue(&Q,0); /*添加第一行末尾的行分界0並入隊*/
EnQueue(&Q,1); /*第二行的兩個1值入隊列*/
EnQueue(&Q,1);
k=2;
while(k<n){ /*通過循環隊列輸出第2行到第n-1行的值*/
for(i=1;i<=n-k;i++)
{printf(" "); fputc(ch,fq);} /*輸出n-k個空格以保持三角形*/
EnQueue(&Q,0);
do{ /*輸出第k行，計算第k+1行*/
DeQueue(&Q,&s);
GetHead(&Q,&e);
if(e) /*若e為非行分界值0，則列印輸出e的值,並加一空格*/
{printf("%d ",e); fprintf(fq,"%d%c",e,ch); }
else
{ printf("\n"); fputc('\n',fq);} /*回車換行，為下一行輸出做准備*/
EnQueue(&Q,s+e); /*計算所得抵k+1行的值入隊列*/
}while(e!=0);
k++;
}
DeQueue(&Q,&e); /*行界值「0「出隊列*/
while(!QueueEmpty(&Q)){ /*單獨處理第n行的值的輸出*/
DeQueue(&Q,&e);
{ printf("%d ",e); fprintf(fq,"%d%c",e,ch); }
}
}
int main(void)
{
FILE * fp;
QElemType n;
if((fp=fopen("input.txt","r"))==NULL){ /*打開寫入文件*/
printf("error on open\n");
exit (1);
}
fscanf(fp,"%d",&n); /*讀入n*/
fclose(fp);
yanghuiTriangle(n);
getch();
return 0;
}
用一個文件輸入一個N，這個數位楊輝三角的行數上面是用循環隊列做的，你看看

2. C語言用數組實現順序隊列求大神幫助

#include "stdio.h" main() { int que[200] = {0} ; int start = 0, end = 0; int i; char ch; printf("please enter 6 num:"); for(i=0;i<6;i++) scanf("%d",&que[i]); end = 5; for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); while(1) { printf("What do you want to do? \n'i' to insert\n'd' to delete\n'q' to quit\n"); switch(ch = getch()) { case 'i': end++; printf("please enter the num:"); scanf("%d",&que[end]); for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); break; case 'd': start++; for(i=start;i<=end;i++) printf("%d ",que[i]); printf("\n"); break; case 'q': exit(0); } } }

3. 數組實現隊列

#include<stdlib.h>
#include<stdio.h>
#include<memory.h>
typedef struct
{
int first;//fist保存了數組第一個元素的索引。
int last;//last保存了數組最後一個元素的索引的下一個位置。
int max_size;//max_size成員保存了數組的總大小
long* ele;//保存了數組的首地址
} Queue;
bool InQueue(Queue *que,long element)
{
if(que->last-que->first>=que->max_size)//空間不夠
{
que->max_size+=10;
long *temp=(long*)malloc(sizeof(long)*(que->max_size));
if(temp)
{
if(que->ele)
{
memcpy(temp,que->ele,que->max_size);
free(que->ele);
}
que->ele=temp;
return InQueue(que,element);
}
return false;
}
else if(que->last<que->max_size)//尾部有空間
{
que->ele[que->last++]=element;
return true;
}
else if(que->first>=1)//首部有空間
{
for(int i=que->first-1;i<que->last-1;i++)
{
que->ele[i]=que->ele[i+1];
}
que->last--;
return InQueue(que,element);
}
return false;
}
bool QuitQueue(Queue *que,long *x)
{
if(que->last>que->first)
{
*x=que->ele[que->first];
que->first++;
return true;
}
return false;
}
bool GetTop(Queue*que,long *x)
{
if(que->last>que->first)
{
*x=que->ele[que->first];
return true;
}
return false;
}
void ClearQueue(Queue *que)
{
que->first=que->last=0;
que->max_size=0;
free(que->ele);
}
int main()
{
Queue que={0};
InQueue(&que,10);
long x;
GetTop(&que,&x);
printf("%d",x);

}

4. 用C語言編寫隊列的各種基本操作，我不是非常明白：注釋里有些問題：請大家講講，如果可能，請詳細講講各種

ont）進行刪除操作，而在表的後端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。 在隊列這種數據結構中，最先插入在元素將是最先被刪除；反之最後插入的元素將最後被刪除，因此隊列又稱為「先進先出」（FIFO—first in first out）的線性表。 隊列空的條件：front=rear 隊列滿的條件： rear = MAXSIZE 隊列可以用數組Q[1…m]來存儲，數組的上界m即是隊列所容許的最大容量。在隊列的運算中需設兩個指針：head，隊頭指針，指向實際隊頭元素的前一個位置；tail，隊尾指針，指向實際隊尾元素所在的位置。一般情況下，兩個指針的初值設為0，這時隊列為空，沒有元素。圖1 ( a)畫出了一個由6個元素構成的隊列，數組定義Q[1…10]。Q(i) i=3,4,5,6,7,8頭指針head＝2，尾指針tail＝8。隊列中擁有的元素個數為:L=tail-head現要讓排頭的元素出隊，則需將頭指針加1。即head=head+1這時頭指針向上移動一個位置，指向Q(3)，表示Q(3)已出隊。見圖1 (b)。如果想讓一個新元素入隊，則需尾指針向上移動一個位置。即tail=tail+1這時Q(9)入隊，見圖1 (c)。當隊尾已經處理在最上面時，即tail=10，如果還要執行入隊操作，則要發生"上溢"，但實際上隊列中還有三個空位置，所以這種溢出稱為"假溢出"。 克服假溢出的方法有兩種。一種是將隊列中的所有元素均向低地址區移動，顯然這種方法是很浪費時間的；另一種方法是將數組存儲區看成是一個首尾相接的環形區域。當存放到n地址後，下一個地址就"翻轉"為1。在結構上採用這種技巧來存儲的隊列稱為循環隊列。 隊列和棧一樣只允許在斷點處插入和刪除元素。 循環隊的入隊演算法如下： 1、tail=tail+1； 2、若tail=n+1，則tail=1； 3、若head=tail尾指針與頭指針重合了，表示元素已裝滿隊列，則作上溢出錯處理； 4、否則，Q(tail)=X，結束（X為新入出元素）。 隊列和棧一樣，有著非常廣泛的應用。

具體網上查:

另外,虛機團上產品團購,超級便宜

5. C語言數組 隊列

intpoint[2][10]={0};
voidaddline(x,y)
{
inti;
for(i=0;i<10;i++)
if(point[1][i]==0&&point[2][i]==0)
break;
if(i<10)
{
point[1][i]=x;
point[2][i]=y;
}
else
{
for(i=0;i<9;i++)
{
point[1][i]=point[1][i+1];
point[2][i]=point[2][i+1];
｝
point[1][9]=x;
point[2][9]=y;
}
}

存進去的坐標不能是0，0

6. C語言，用數組實現隊列的入隊，出隊函數編程

這樣的話應該符合你的要求：

#include<stdio.h>
voidadd(intqueue[],intx);
intTop(intqueue[]);
voiddel(intqueue[]);
intend=0;
intmain()
{
intn;
scanf("%d",&n);//將要入隊列n個元素
intqueue[1000];
for(inti=1;i<=n;i++)//輸入n個元素
{
add(queue,i);//將i加入隊列
}
//驗證加入隊列的元素，將隊列中的元素按照輸入的順序輸出：
for(i=1;i<=n;i++)
{
printf("%d",Top(queue));//Top函數返回隊頭元素
del(queue);//刪除隊頭元素
}
//驗證輸出已經出隊列後的隊列（數組）元素：
printf("
");
for(i=1;i<=n;i++)
printf("%d",queue[i]);
printf("
");
return0;
}
voidadd(intqueue[],intx)
{
queue[++end]=x;
}
intTop(intqueue[])
{
returnqueue[1];//注意，這里的函數始終returnqueue[1];這里是和將普通數組中的元素輸出最大的不同之處。！！！！！！
}
voiddel(intqueue[])
{
for(inti=2;i<=end;i++)
{
queue[i-1]=queue[i];
}
queue[end]=0;//將刪除後的地方置0
end--;
}

7. c語言循環隊列

隊列是一種特殊的線性表，循環隊列是將向量空間想像為一個首尾相接的圓環。

隊列是一個特殊的線性表，它的特殊之處在於它只允許表的前面的操作刪除，而在表的後面的操作插入，就像堆棧一樣，隊列100是一個線性表，具有有限的操作。

循環隊列就是把向量空間想像成一個首尾相連的環，把這樣的向量稱為循環向量。存儲學位的隊列稱為循環隊列。

在順序隊列中，當指向隊列末端的指針到達數組的上界時，不能有更多的隊列條目，但數組中仍然有一個空位置。這稱為「假溢出」。

(7)隊列數組c語言實現擴展閱讀：

判斷滿隊列狀態：

1．計數；你通常使用count

Count等於隊列的MAXSIZE

2．國旗int

Queueinflag＝1Queueoutflag＝0

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

3．放一個存儲應答單元為空，不存儲數據

後面＋1＝前面

註：（不）順序結構，SeqQueuemyQueue；

8. C語言的隊列如何實現和表示

我能想到的有兩種方法（假設隊列元素都是int）
一，用鏈表的方法
struct A
{
int n;
struct A *a;
} *p,*head,*rear;
head=rear=NULL；/*頭指針，尾指針*/
添加元素：p=(struct A*)malloc(sizeof(struct A));......給新元素賦值.....;rear->a=p;rear=p;
當然添加第一個元素的時候要給head賦值。
刪除元素：p=head;head=head->a;free(p);
用的是單向鏈表，當然也可以用雙向鏈表，不過刪除，添加元素的過程要麻煩點。
二，利用數組，當然也可以開辟動態儲存空間
int a[N]，*head,*rear; N就是個常數
head=rear=a;
添加元素：scanf("%d",rear-a==N?rear=a:++rear);
刪除元素：head-a==N?head=a:head++;
當然要檢查隊列是否溢出，可以設變數n=0;
每次添加元素n++
每次刪除元素n--
當n<0後n>N數據溢出

9. 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];

10. c語言實現隊列和棧的方法

#define OVERFLOW -1
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define N 20
typedef char SElemType;
typedef int Status;typedef struct {
SElemType *base;
SElemType *top;
int stacksize;
}SqStack;#include<stdio.h>
#include<stdlib.h>Status CreatStack(SqStack &S){
//創建棧
S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType));
if(!S.base)exit(OVERFLOW);
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//CreatStackStatus Push(SqStack &S,SElemType e){
//插入e為新的棧頂元素
if(S.top-S.base>=S.stacksize){//棧滿，追加存儲空間
S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
if(!S.base)exit (OVERFLOW);//存儲空間分配失敗
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//PushStatus Pop(SqStack &S ,SElemType &e){
//若棧不空，刪除棧頂元素，並用e返回其值
if(S.top==S.base) return ERROR;
e=*--S.top;
return OK;
}//Pop typedef char QElemType;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QNodePtr;typedef struct{
QNodePtr front;
QNodePtr rear;
}LinkQueue;Status CreatQueue(LinkQueue &Q){
//建立一個空的鏈式棧
Q.front=Q.rear=(QNodePtr)malloc(sizeof(QNode));
if(!Q.front)exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}Status EnQueue(LinkQueue &Q,QElemType e){ QNodePtr p;
p=(QNodePtr)malloc(sizeof(QNode));
if(!p)exit(OVERFLOW);
p->data=e;p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}Status DeQueue(LinkQueue &Q,QElemType &e){QNodePtr p;<br>if(Q.front==Q.rear) return ERROR;<br>p=Q.front->next; e=p->data;<br>Q.front->next=p->next;<br>if(Q.rear==p) Q.rear=Q.front;<br>free(p);<br>return OK;<br>}int stackPalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("棧練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
SqStack S;
CreatStack(S);
char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
Push(S,b[count]); //進棧
count++;
}
int i = 0;
while(i < count)
{
Pop(S,a);
if(a!=b[i])
return ERROR;
i++;
}
return OK;}//stackPalindrom_Test int queuePalindrom_Test()//判別輸入的字元串是否迴文序列,是則返回1,否則返回0
{
printf("隊列練習，請輸入要判斷的字元串以#作為結束符，不要超過二十個字元\n");
LinkQueue Q;
CreatQueue(Q); char c;
SElemType a;
SElemType b[N];
int count = 0;
fgets( b, N, stdin );
while((b[count])!='#')
{
EnQueue(Q,b[count]);; //入列
count++;
} while(count-- > 0)
{
DeQueue(Q,a);
if(a!=b[count])
return ERROR;
}
return OK;
}//queuePalindrom_Test Status main(){ if(stackPalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n"); if(queuePalindrom_Test()==1)
printf("是迴文\n");
else printf("不是迴文\n");
return OK;
}