Question

帮 忙用c语言编个队列的源程序,一定能运行的哈

建立一队列（链式的 一定 是 ），实现以下操作：
1、队满能自动删除队头元素；
2、入队；
3、能 显示所有元素。
(数据元素最好是 string或char类型的 .因为 我 想 用这个队列实现一个 linux的 shell的 命令回溯工能 .)

Answer 1

vc下的程序，适当更改下

#include <stdio.h>
#include <stdlib.h>

typedef char ElemType;

//定义链队列
typedef struct lnode
{
ElemType data;
struct lnode *next;
}LNode;//定义一个普通链表

typedef struct
{
LNode *front;
LNode *rear;
}LQueue;//将头尾指针封装在一起的链队

//初始化链队列，创建一个带头节点的空对
LQueue* Init_LQueue()
{
LNode *p;//定义为链表指针
LQueue *q;

p=(LNode*)malloc(sizeof(LNode));
if(p==NULL)
{
printf("malloc error\n");
return NULL;
}
q=(LQueue*)malloc(sizeof(LQueue));
if(q==NULL)
{
free(p);
printf("malloc error\n");
return NULL;
}
p->next=NULL;
q->front=q->rear=p;
return q;

}

//链队列入对
int In_LQueue(LQueue *q,ElemType x)
{
LNode *p;//链表指针

p=(LNode*)malloc(sizeof(LNode));//开辟新空间
if(p==NULL)
{
printf("malloc error\n");
return 0;
}
p->data=x;
p->next =NULL;//链尾置空

q->rear->next=p;//对尾指向链尾
q->rear=p;//对尾后移

return 1;
}

//链队列出对
int Out_LQueue(LQueue *q,ElemType &x)
{
LNode *p;

if(q->front == q->rear)
{
printf("链队列为空!不能出对!\n");
return 0;
}

p=q->front->next;//找到对头第一个有值节点
x=p->data;//取出数值
q->front->next=p->next;
free(p);
if(q->front->next == NULL)//当出对为最后一个节点时，修改头尾指针.
q->front = q->rear;
return 1;
}

//求队列的长度
int LQueueLen(LQueue *q)
{
int length=0;
LNode *p;

p=q->front;
while(p!=q->rear)
{
length++;
p=p->next;
}
return length;
}

//打印链队列
int Print_lq(LQueue *q)
{
LNode *p;

p=q->front->next;//注意在链头那里不存放数据,从后面开始算
if(q->front == q->rear)
{
printf("链队列为空!\n");
return 0;
}

while(p!=NULL)
{
printf("%c,",p->data);
p=p->next;
}
printf("\n");
return 1;
}

//释放链队列
int Free_LQueue(LQueue *q)
{
LNode *p,*t;

p=q->front->next;
while(p!=NULL)
{
t=p->next;
free(p);//释放链表
p=t;
}
q->front=q->rear=NULL;//置队列为空
return 1;
}

int main()
{
int i;
ElemType x;
LQueue *lq=NULL;

lq=Init_LQueue();//形成对头

printf("链队列入对...\n");
for(i=0;i<10;i++)
{
In_LQueue(lq,i+'a');
}
//打印链队列
Print_lq(lq);

//链队列长度
printf("链队列长度:%d\n",LQueueLen(lq));

//链队列出对
printf("链队列出对...\n");
Out_LQueue(lq,x);
printf("链队列出对数值为:%c\n",x);
//打印链队列
Print_lq(lq);

//释放链队列
Free_LQueue(lq);

getchar();
return 0;
}

Answer 2

设计一个主函数(保存于lqueue.c)，对链式队列（保存于lqueue.h）进行测试，测试方法为：依次所数据元素1，2，3，4，5入栈，然后出队并在屏幕上显示出栈的数据元素。
运行结果:
输入数据元素:1 2 3 4 5
输出数据元素:1 2 3 4 5

Answer 3

调用stl里边的queue（）函数。。可以很容易的完成增，删，改，查，判空等操作。。很方便。。

Answer 4

#include <iostream>
#include <stdlib.h>
using namespace std;
#define OVERFLOW 0

const int ERROR=0;
const int OK=1;
typedef int QelemType;
typedef int Statues;

typedef struct QNode{
QelemType data;
struct QNode *next;
}QNode,*QueuePtr;

typedef struct{
QueuePtr front;//对头指针
QueuePtr rear;//队尾指针
}LinkQueue;

Statues visit(QelemType Queueelem){
cout<<Queueelem<<" "<<endl;
return OK;
}

/************************************************************************/
/*初始化队列 分配头指针和尾指针以后的操作中头指针不变，改变尾指针
*/
/************************************************************************/
Statues InitQueue(LinkQueue &Q){
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if (!Q.front)
{
exit(OVERFLOW);
}
Q.front->next=NULL;
return OK;
}

/************************************************************************/
/*入队列
*/
/************************************************************************/
Statues EnQueue(LinkQueue &Q,QelemType e){
QueuePtr p=(QueuePtr)malloc(sizeof(QNode));
if (!p)
{
return ERROR;
}
p->data=e;
p->next=NULL;
Q.rear->next=p; //将队列最后一个元素的指针指向p
Q.rear=p; //p作为队列最后一个元素
return OK;
}

/************************************************************************/
/*出队列
*/
/************************************************************************/
Statues DeQueue(LinkQueue &Q,QelemType &e){
if (Q.front==Q.rear)
{
return ERROR; //队列为空返回
}
QueuePtr p=Q.front->next;
e=p->data;
Q.front->next=p->next;//见数据结构p61图3.8
if (Q.rear==p) //若Q.rear==p则表示当前出列元素为队列最后一个元素
{
Q.rear=Q.front;
}
free(p);
return OK;
}

/************************************************************************/
/*判断队列是否为空,为空则返回真值，不空则返回假值
*/
/************************************************************************/
Statues QueueEmpty(LinkQueue Q){
if (Q.front==Q.rear)
{
return OK;
}
else{
return ERROR;
}
}

/************************************************************************/
/*获取对头元素值 ,如果队列为空则返回假，否则返回真，并且e记录元素
*/
/************************************************************************/
Statues GetHead(LinkQueue Q,QelemType &e){
if (QueueEmpty(Q))
{
return ERROR;
}
else{
QueuePtr p=Q.front->next;
e=p->data;
return OK;
}
}

/************************************************************************/
/*获取队尾元素值
*/
/************************************************************************/
Statues GetRear(LinkQueue Q,QelemType &e){
if (QueueEmpty(Q))
{
return ERROR;
}
else{
e=Q.rear->data;
return OK;
}
}

/************************************************************************/
/*计算队列长度
*/
/************************************************************************/
int QueueLength(LinkQueue Q){
if (QueueEmpty(Q))//队列为空 返回0；
{
return 0;
}
else{
QueuePtr p=Q.front;
int length=0;
while (p!=Q.rear)
{
length++;
p=p->next;
}
return length;
}
}

/************************************************************************/
/*销毁队列
*/
/************************************************************************/
Statues DestroyQueue(LinkQueue &Q){
while(Q.front){
Q.rear=Q.front->next;//每次释放头指针所指内存，直到队列空间释放完全
free(Q.front);
Q.front=Q.rear;
}
return OK;
}

/************************************************************************/
/*清空队列
*/
/************************************************************************/
Statues ClearQueue(LinkQueue &Q){
QueuePtr p=Q.front->next,temp;
while (p)
{
temp=p;
p=p->next;
Q.front->next=p;
free(temp);//释放内存
}
Q.rear=Q.front;
return OK;
}

/************************************************************************/
/*浏览队列所有元素
*/
/************************************************************************/
Statues TravelQueue(LinkQueue Q,Statues(*visit)(QelemType )){
QueuePtr p=Q.front->next;
while (p)
{
if (!(*visit)(p->data))
{
return ERROR;
}
p=p->next;
}
return OK;
}

void main(){
LinkQueue queue;
QelemType elem;
InitQueue(queue);
while (cin>>elem && elem!=-1)//elem不等于-1只为测试结束输入方便
{
EnQueue(queue,elem);
}
if (GetHead(queue,elem))
{
cout<<"列头元素值为： "<<elem<<endl;
}
if (GetRear(queue,elem))
{
cout<<"列尾元素为： "<<elem<<endl;
}
cout<<"队列长度为： "<<QueueLength(queue)<<endl;
cout<<"########################"<<endl;
cout<<"遍历队列元素："<<endl;
TravelQueue(queue,visit);
cout<<"########################"<<endl;
if (DeQueue(queue,elem))
{
cout<<"出列元素为："<<elem<<endl;
}
ClearQueue(queue);
cout<<"清空后队列长度为： "<<QueueLength(queue)<<endl;
cout<<"########################"<<endl;
cout<<"遍历队列元素："<<endl;
TravelQueue(queue,visit);
cout<<"########################"<<endl;
if (DestroyQueue(queue))
{
cout<<"队列销毁成功"<<endl;
}
}
刚刚编译通过 元素类型你typedef int QelemType;把int 改成你想要的类型

Answer 5

#include <stdio.h>
#include <stdlib.h>
typedef struct QNode{
int data;
struct QNode *next;
} LinkNode;//每个结点的定义

typedef struct{
LinkNode *front, *rear;
}LinkQuene;//采用链表结构的队列

void InitQuene(LinkQuene &Q)//带有头结点的队列
{
Q.front=(LinkNode *)malloc(sizeof(QNode));
Q.rear=Q.front;
}

bool EmptyQuene(LinkQuene Q)
{
if(Q.front==Q.rear)
return true;
else
return false;
}

void QueneTraverse(LinkQuene Q)
{
if(EmptyQuene(Q)==false)
{
LinkNode *p=Q.front->next;
printf("\n当前队列的遍历序列为：");
while(p!=Q.rear)
{
printf("%d->",p->data);
p=p->next;
}
printf("%d\n",p->data);
}
}

void EnQuene(LinkQuene &Q, int e)
{
LinkNode *p=(LinkNode *)malloc(sizeof(QNode));
if(!p)
exit(0);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
}

void DeQuene(LinkQuene &Q, int &e)
{
LinkNode *p;
if(EmptyQuene(Q))
{ printf("队列为空！\n");
exit(0);
}

p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
}

void menu()
{
printf("\n***************************\n");
printf("**[1]新建队列 **\n");
printf("**[2]入队列 **\n");
printf("**[3]出队列 **\n");
printf("**[4]遍历整个队列 **\n");
printf("**[0]退出 **\n");
printf("***************************\n");
printf("请输入命令：\n");
}
void main()
{
LinkQuene Q;
InitQuene(Q);
int a,order;
char ans,temp;
while(1)
{
menu();
ans='n';
scanf("%d",&order);
switch(order)
{
case 1:
do{
printf("请输入队列的元素：\n");
scanf("%d",&a);
fflush(stdin); //清空键盘缓冲区（过滤回车）
EnQuene(Q,a);
printf("是否继续添加元素？(Y/N)");
scanf("%c",&ans);
fflush(stdin);
}while(ans=='y' || ans =='Y');
QueneTraverse(Q);
break;
case 2:
if( EmptyQuene(Q))
{
printf("队列为空!\n");
break;
}
do{
printf("请输入添加到队列的元素：\n");
scanf("%d",&a);
fflush(stdin);
EnQuene(Q,a);
printf("是否继续添加元素?(Y/N)");
scanf("%c",&ans);
fflush(stdin);
}while(ans=='y' || ans =='y');
QueneTraverse(Q);
break;

case 3:
if(EmptyQuene(Q))
{
printf("队列为空!\n");
break;
}
else{
do{
DeQuene(Q,a);
fflush(stdin);
printf("元素%d已经出队列\n",a);
if(EmptyQuene(Q)==false)
{
printf("是否继续出队列?(Y/N)");
scanf("%c",&ans);
}
else
{
printf("队列已空!\n");
break;
}
}while(ans=='y' || ans =='y');
QueneTraverse(Q);
break;
}
case 4:
if(EmptyQuene(Q))
{
printf("队列为空!\n");
break;
}
QueneTraverse(Q);break;
case 0:
exit(0);
default:
printf("您输入的命令有误!\n");

}
}
}