c語言隊列的應用

1. 棧與隊列的應用（c語言）求解

#include "stdio.h"
#include "malloc.h"
typedef struct node1{
int *data;
int top;
void init(void);
void del(void);
int pop(int&);
void push(int&);
}s;
void node1::init(){
data=(int*)malloc(sizeof(int)*100);
top=0;
}
void node1::del(){
free(data);
top=0;
}
int node1::pop(int &e){
if(top==0)return 0;
e=data[--top];
return 1;
}
void node1::push(int &e){
if(top==100)return;
data[top++]=e;
}
typedef struct node2{
int *data;
int top;
int bottom;
void init(void);
void del(void);
int pop(int&);
void push(int&);
void format(s&);
}q;
void node2::init(){
data=(int*)malloc(sizeof(int)*100);
top=bottom=0;
}
void node2::del(){
free(data);
top=bottom=0;
}
int node2::pop(int &e){
if(top==bottom)return 0;
e=data[top++];
return 1;
}
void node2::push(int &e){
if(bottom==100)return;
data[bottom++]=e;
}
void node2::format(s &e){
int a;
while(e.pop(a)){
push(a);
}
}
int main(){
s b;q c;
int a;
b.init();c.init();
printf("輸入棧中的數,以0結尾\n");
while(1){
scanf("%d",&a);
if(a==0)break;
b.push(a);
}
c.format(b);
while(c.pop(a)){
printf("%d\n",a);
}
b.del();
c.del();
return 0;
}//b為棧,c為隊列,c.format(b)為轉換函數

2. C語言實現隊列的基本操作

structpQueue
{
	ElemType*head;//指向開辟的空間的首地址
Elemtype*tail;
	intlength;//(總容量)
	intL_now;//(當前容量)
};
if(pQueue.L_now==pQueue.length)
{
每次申請空間都是+N
}
pQueue->tail=p;

3. 二級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；

4. C語言中使用隊列

如果你用vc，#include<deque>就好了，但是注意要加上using naemspace std；
我是當你用的c++的STL，STL中沒有真正的隊列和棧，他們都是通過對雙端隊列的改造得到的，所以包含的文件可能和你想的不一樣。而且這些頭文件都沒有.h結尾！很特別
如果你不是vc，當我沒說

5. 我想要c語言，隊列方面最基礎的知識，基本操作

隊列是一種特殊的線性表，它只允許在表的前端（front）進行刪除操作，而在表的後端（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為新入出元素）。 隊列和棧一樣，有著非常廣泛的應用。

具體網上查:
http://ke..com/view/38959.htm?fr=ala0_1_1

6. 數據結構（使用C語言）隊列

對順序循環隊列，常規的設計方法是使用隊尾指針和隊頭指針，隊尾指針用於指出當前胡隊尾位置下標，隊頭指針用於指示當前隊頭位置下標。現要求：
（1）設計一個使用隊頭指針和計數器胡順序循環循環隊列抽象數據類型，其中包括：初始化，入隊列，出隊列，取隊頭元素肯判斷隊列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{

intdata[MAX];

intfront,rear;

intnum;
}SeQue;
SeQue*Init_SeQue()
{

SeQue*s;

s=newSeQue;

s->front=s->rear=MAX-1;

s->num=0;

returns;
}
intEmpty_SeQue(SeQue*s)
{

if(s->num==0)

return1;

else

return0;
}
intIn_SeQue(SeQue*s,intx)
{

if(s->num==MAX)

return0;

else

{

s->rear=(s->rear+1)%MAX;

s->data[s->rear]=x;

s->num++;

return1;

}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))

return0;
else
{

s->front=(s->front+1)%MAX;

*x=s->data[s->front];

s->num--;

return1;
}
}
voidPrint_SeQue(SeQue*s)
{

inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);

i=(i+1)%MAX;

n--;
}
}
voidmain()
{

SeQue*s;

intk,flag,x;

s=Init_SeQue();

do{

printf("\");

printf("\t\t\t循環順序隊列");

printf("\t\t\t***********************");

printf("\t\t\t**1-入隊**");

printf("\t\t\t**2-出隊**");

printf("\t\t\t**3-判隊空**");

printf("\t\t\t**4-隊列顯示**");

printf("\t\t\t**0-返回**");

printf("\t\t\t***********************");

printf("\t\t\t請輸入菜單項(0-4):");

scanf("%d",&k);

switch(k)

{

case1:


printf("請輸入入隊元素:");


scanf("%d",&x);


flag=In_SeQue(s,x);


if(flag==0)


printf("隊滿不能入隊!按任意鍵返回..");


else


printf("元素已入隊!按任意鍵返回..");


getch();


system("cls");


break;

case2:


flag=Out_SeQue(s,&x);


if(flag==0)


printf("隊列空出隊失敗!按任意鍵返回..");


else


printf("隊列頭元素已出隊~!按任意鍵返回..");


getch();


system("cls");


break;

case3:


flag=Empty_SeQue(s);


if(flag==1)


printf("該隊列為空!按任意鍵返回..");


else


printf("該隊列不為空!按任意鍵返回..");


getch();


system("cls");


break;

case4:


printf("該隊列元素為:");


Print_SeQue(s);


printf("按任意鍵返回..");


getch();


system("cls");


break;

}

}while(k!=0);
}

7. c語言隊列操作

pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。

8. C語言鏈表和棧，還用隊列分別用於什麼場合，請專業人士具體解說一下！

通常鏈表支持線性時間查找，線性時間訪問，常數時間插入，常數時間刪除，比較適合需要多次在中間插入和刪除的場合
棧(stack)遵循先進後出原則(FILO)，可用於模擬倉儲，遞歸，深搜等其他符合FILO的模型
隊列(queue)遵循先進先出原則(FIFO),可用於模擬排隊，流，消息隊列等符合FIFO的模型

其他具體情況就要視需要而定了

9. 棧的應用，隊列的應用（用C語言編寫程序）

//第一個問題
#include <stdio.h>
#include<stdlib.h>
struct stack{
char a;
struct stack *last;
}*top,*head,*p;
void SetStack(){
top=(stack*)malloc(sizeof(stack));
top->last=NULL;
head=NULL;
}
bool StackIsNull(){
return head==NULL;
}
void push(char x){
if(StackIsNull()){
top->a=x;
head=top;
return;
}
p=(stack*)malloc(sizeof(stack));
p->a=x;
p->last=head;
head=p;
}
char pop(){
char x=head->a;
p=head;
head=head->last;
free(p);
return x;
}
void main(){
SetStack();
char c;
while((c=getchar())!='\n'&&c!=' ') push(c);
while(!StackIsNull()) printf("%c",pop());
printf("\n");
}
//第二個
#include<stdio.h>
#include<stdlib.h>
struct queue{
int a;
struct queue *next;
}*top,*head,*p;
void SetQueue(){
top=NULL;
}
bool QueueIsNull(){
return top==NULL;
}
void In(int x){
if(QueueIsNull()){
top=(queue*)malloc(sizeof(queue));
top->a=x;
top->next=NULL;
head=top;
return;
}
p=(queue*)malloc(sizeof(queue));
p->a=x;
p->next=NULL;
head->next=p;
head=p;
}
int Out(){
p=top;
top=top->next;
int x=p->a;
free(p);
return x;
}
void main(){
SetQueue();
printf("輸入要列印的行數\n");
int n;
scanf("%d",&n);
if(n<=0) return;
In(1);
In(1);
for(int j=0;j<n-1;j++) printf(" ");
printf("1 1\n");
for(int i=1;i<n;i++){
for(j=0;j<n-i-1;j++) printf(" ");
int temp=0;
int now=Out();
do{
printf("%d ",temp+now);
In(temp+now);
temp=now;
}while((now=Out())!=1);
printf("%d ",temp+now);
In(temp+now);
In(1);
printf("1 \n");
}
}

10. 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數據溢出