本文目录一览：
- 1、C语言队列
- 2、队列的源代码（c语言）
- 3、用C语言编写队列程序
- 4、c语言队列操作
- 5、队列（c语言代码）
- 6、求一段C语言的 队列 数据结构代码,能用的就加分啊!
C语言队列
C语言的队列（queue），是指先进先出（FIFO, First-In-First-Out）的线性表。在具体应用中通常用链表或者数组来实现。队列只允许在后端（称为rear）进行插入操作，在前端（称为front）进行删除操作
单链表形式（单链队列使用链表作为基本数据结果，因此不存在伪溢出的问题，队列长度也没有限制。但插入和读取的时间代价会比较高）
队列的源代码（c语言）
以前写的.你可以看看咯..
class Queue
{
struct Node
{
int a;
Node * next;
};
public:
Queue();
void pump(int b);
void pop();
int getlength();
virtual void print();
private:
Node * head;
Node * rear;
};
void Queue::pump(int b)
{
Node *p1=new Node;
p1-a=b;
p1-next=NULL;
rear-next=p1;
rear=p1;
head-a++;
coutsetw(2)bsetw(2)" 进入队列 "endl;
}
void Queue::pop()
{
Node *p;
p=head-next;
cout" "setw(2)p-asetw(2)"出队"endl;
head-next=p-next;
delete p;
head-a--;
}
int Queue::getlength()
{
return head-a;
}
void Queue::print()
{
Node *p;
p=head-next;
cout"队列中的元素是:"endl;
while(p)
{
coutp-a" - ";
p=p-next;
}
cout"NULL"endl;
}
Queue::Queue()
{
rear=head;
};
用C语言编写队列程序
#includestdio.h
#includestdlib.h
#includemalloc.h
#define TRUE 1
#define FALSE 0
#define NULL 0
#define OK 1
#define OVERFLOW 0
#define ERROR 0
typedef int QElemType;
typedef int Status;
typedef struct QNode
{
QElemType data;
QNode *next;
}*QueuePtr;
struct LinkQueue
{
QueuePtr front,rear;//队头，队尾指针
};
//函数列表
void InitQueue(LinkQueue Q)
{//初始化一个队列
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front)//生成头结点失败
exit(OVERFLOW);
Q.front-next=NULL;
}
void DestoryQueue(LinkQueue Q)
{ //销毁队列
while(Q.front)
{
Q.rear=Q.front-next;//Q.rear指向Q.front的下一个结点
free(Q.front);//释放Q.front所指结点
Q.front=Q.rear;//Q.front指向Q.front的下一个结点
}
}
void ClearQueue(LinkQueue Q)
{ //将队列清为空
DestoryQueue(Q);//销毁队列
InitQueue(Q);//重新构造队列
}
Status QueueEmpty(LinkQueue Q)
{ //判断队列是否为空
if(Q.front-next==NULL)
return TRUE;
else return FALSE;
}
int QueueLength(LinkQueue Q)
{ //求队列的长度
int i=0;//计数器清0
QueuePtr p=Q.front;//p指向结点
while(Q.rear!=p)//p所指向的不是尾结点
{
i++;//计数器加1
p=p-next;
}
return i;
}
Status GetHead(LinkQueue Q,QElemType e)
{ //若队列不空，则用e返回队头元素
QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front-next;//p指向队头结点
e=p-data;//将队头元素的值赋给e
return OK;
}
void EnQueue(LinkQueue Q,QElemType e)
{ //插入元素e为队列Q的新的队尾元素
QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
//动态生成新结点
if(!p)
exit(OVERFLOW);
p-data=e;//将e的值赋给新结点
p-next=NULL;//新结点的指针为空
Q.rear-next=p;//原队尾结点的指针域为指向新结点
Q.rear=p;//尾指针指向新结点
}
Status DeQueue(LinkQueue Q,QElemType e)
{ //若队列不为空，删除Q的队头元素，用e返回其值
QueuePtr p;
if(Q.front==Q.rear)//队列为空
return ERROR;
p=Q.front-next;//p指向队头结点
e=p-data;//队头元素赋给e
Q.front-next=p-next;//头结点指向下一个结点
if(Q.rear==p)//如果删除的队尾结点
Q.rear=Q.front;//修改队尾指针指向头结点
free(p);
return OK;
}
void QueueTraverse(LinkQueue Q,void(*visit)(QElemType))
{ //对队头到队尾依次对队列中每个元素调用函数visit()
QueuePtr p;
p=Q.front-next;
while(p)
{
visit(p-data);//对p所指元素调用visit()
p=p-next;
}
printf("\n");
}
void print(QElemType e)
{
printf("%2d",e);
}
void main()
{
int i,k;
QElemType d;
LinkQueue q;
InitQueue(q);//构造一个空栈
for(i=1;i=5;i++)
{
EnQueue(q,i);
}
printf("栈的元素为:");
QueueTraverse(q,print);
k=QueueEmpty(q);
printf("判断栈是否为空,k=%d(1:为空9;0:不为空)\n",k);
printf("将队头元素赋给d\n");
k=GetHead(q,d);
printf("队头元素为d=%d\n",d);
printf("删除队头元素:\n");
DeQueue(q,d);
k=GetHead(q,d);
printf("删除后新的队头元素为d=%d\n",d);
printf("此时队列的长度为%d\n",QueueLength(q));
ClearQueue(q);//清空队列
printf("清空队列后q.front=%u,q.rear=%u,q.front-next=%u\n",q.front,q.rear,q.front-next);
DestoryQueue(q);
printf("销毁队列后,q.front=%u,q.rear=%u\n",q.front,q.rear);
c语言队列操作
pq-rear-next
=
pnew这个代码从队列的尾部增加新节点，
然后pq-rear
=
pnew更新队列尾部指针。队列的数据结构形式就是由一个头front指针，一个尾rear指针来表征，items的设计是用空间换时间，涉及队列大小的操作会非常方便。
队列的特征是先进先出，你给出的链式实现，其实就跟一个链表一样，链表的添加删除如果能理解了，队列只是链表的元素增加/删除
按先进先出特点的一种实现。
但对于队列来说，实现方式不是重点，先进先出的性质才是重点，这在实际应用中很多，比如排队叫号。
队列（c语言代码）
队头是front,队尾是rear；
队头出数据，队尾进数据；
队头指针front 不存数据；
当front == rear时 队列为空；
清空或取出数据至队列为空时记得将rear指针移到front上；
求一段C语言的 队列 数据结构代码,能用的就加分啊!
#ifndef QUEUE_H
#define QUEUE_H
#include iostream
using std::cout;
using std::endl;
using std::ostream;
template class Type
class Queue {
friend ostream operator (ostream , const QueueType );
public:
static const int DefaultSize;
Queue(int = DefaultSize); //创建一个最大容量为MaxQueueSize的空队列
Queue(Type [], int, int = DefaultSize);
~Queue() {delete [] queue;}
bool IsFull(); //若元素个数等于队列的最大容量则返回true，否则返回false
void Add(const Type ); //若IsFull()为true，调用外处理函数QueueFull()，否则将item插入队尾
bool IsEmpty() const; //若队列中元素个数等于0，则返回true，否则返回false
Type * Delete(Type ); //若IsEmpty()为true，调用QueueEmpty()并返回0，否则删除队列前段元素并返回其指针
void Empty(); //清空队列
void QueueFull(); //扩充1倍的存储空间
void QueueEmpty(); //提示队列已空，元素不能出队
private:
int front, rear;
Type * queue;
int maxSize;
};
template class Type
const int QueueType::DefaultSize = 10;
template class Type
QueueType::Queue(int pMaxSize) {
queue = new Type [pMaxSize];
maxSize = pMaxSize;
front = rear = -1;
}
template class Type
QueueType::Queue(Type pArray[], int pSize, int pMaxSize) {
queue = new Type [pMaxSize];
for (int i = 0; i pSize; i++)
{
queue[i] = pArray[i];
}
front = -1; rear = pSize - 1;
maxSize = pMaxSize;
}
template class Type
bool QueueType::IsFull() {
if ( rear == maxSize - 1 ) return true;
else return false;
}
template class Type
bool QueueType::IsEmpty() const {
if ( rear == front ) return true;
else return false;
}
template class Type
void QueueType::Add(const Type pX) {
if (IsFull())
{
QueueFull();
queue[++rear] = pX;
}
else
{
queue[++rear] = pX;
}
}
template class Type
Type * QueueType::Delete(Type pX) {
if (IsEmpty())
{
QueueEmpty();
return 0;
}
else
{
pX = queue[++front];
return pX;
}
}
template class Type
void QueueType::QueueEmpty() {
cout "队列为空，不能进行出队操作！" endl;
}
template class Type
void QueueType::QueueFull() {
Type * newQueue = new Type [maxSize * 2];
for ( int i = front + 1; i = rear; i++ )
{
newQueue[i] = queue[i];
}
maxSize = maxSize * 2;
delete [] queue;
queue = newQueue;
cout "队列已满，现已增加空间为原来的2倍 " maxSize;
}
template class Type
void QueueType::Empty() {
front = rear = -1;
}
template class Type
ostream operator (ostream pOutput, const QueueType pQ) {
if (pQ.IsEmpty())
{
cout "空队列" endl;
return pOutput;
}
for ( int i = pQ.front + 1; i = pQ.rear; i++ )
{
pOutput pQ.queue[i] " ";
}
cout endl;
return pOutput;
}
#endif
