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数据溢出