① 在循环队列中怎样实现入队和出队操作 数据结构 c语言
有个比较死板的经验：把所有需要操作的变量改成指针SqQueue &Q改成SqQueue *Q，比如把所有的.改成->（因为用C语言需要指针操作）；例如
int InitQueue(SqQueue *Q)
{
Q->base=(char *)malloc(MAXSIZE*sizeof(Elemtype));
if(Q->base==NULL) exit(0);
Q->front=Q->rear=0;
return 1;
} //初始化一个循环队列；
② C语言 数据结构 循环队列插入操作
#include<stdio.h>
#include<malloc.h>
struct link_cqueue
{
int data;
struct link_cqueue *next;
};
//初始化循环链队列
struct link_cqueue *init_link_cqueue()
{
struct link_cqueue *rear;
rear=NULL; /*队尾指针设置为空*/
return rear;
}
//（1）插入（即入队）算法：
struct link_cqueue *EnCQueue(struct link_cqueue *rear, int x)
{ //设循环链队列的队尾指针为rear,x为待插入的元素
struct link_cqueue *p;
p=(struct link_cqueue *)malloc(sizeof(struct link_cqueue));
p->data=x;
if(rear==NULL) //如为空队，建立循环链队列的第一个结点
{
rear=p;
rear->next=p; //链接成循环链表
}
else //否则在队尾插入p结点
{
p->next=rear->next;
rear->next=p;
rear=p;
}
return rear;
}
//（2）删除（即出队）算法：
struct link_cqueue *DeCQueue(struct link_cqueue *rear)
{ //设循环链队列的队尾指针为rear
if (rear==NULL) //空队
printf("队列为空无法删除！\n");
else if(rear->next==rear) //队中只有一个结点
rear=NULL;
else
rear->next=rear->next->next; //rear->next指向的结点为循环链队列的队头结点
return rear;
}
//循环队列的输出
void print_link_cqueue(struct link_cqueue *rear)
{
struct link_cqueue *p;
if(!rear)
printf("队列为空！\n");
else
{
printf("%5d",rear->next->data);
p=rear->next;
while(p!=rear)
{
printf("%5d",p->next->data);
p=p->next;
}
}
printf("\n");
}
main()
{
struct link_cqueue *rear;
int x;
int c;
rear=init_link_cqueue();
do
{
printf("请选择入队或出队操作：1：入队；2：出队；3：输出！\n");
scanf("%d",&c);
if(c==1)
{
printf("请输入要入队的元素：");
scanf("%d",&x);
rear=EnCQueue(rear,x);
}
else if(c==2)
{
rear=DeCQueue(rear);
}
else if(c==3)
print_link_cqueue(rear);
else
printf("选择错误，请重新选择");
}while(1);
}
③ 数据结构（c语言版）队列基本操作的实现
/***************/
/* 链式队列 */
/***************/
#include "stdlib.h"
#include "stdio.h"
/* 定义链式队列类型 */
typedef int ElemType;
typedef struct QNode
{ ElemType data;
struct QNode *next;
} QNode, *QueuePtr;
typedef struct
{ QueuePtr front;
QueuePtr rear;
} LinkQueue;
/* 1、初始化链式队列 */
void InitQueue(LinkQueue *Q)
{ Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
if (!(Q->front)) exit(0);
Q->front->next=NULL; }
/* 2、销毁链式队列 */
void DestroyQueue(LinkQueue *Q)
{ while (Q->front)
{ Q->rear=Q->front->next;
free(Q->front);
Q->front=Q->rear; }
}
/* 3、清空链式队列 */
void ClearQueue(LinkQueue *Q)
{ QueuePtr p;
p=Q->front->next;
while (p)
{ Q->front->next=p->next;
free(p); }
Q->rear=Q->front;
}
/* 4、判断空队列 */
int QueueEmpty(LinkQueue Q)
{ if (Q.front==Q.rear)
return 1;
else
return 0; }
/* 5、求链式队列长度 */
int QueueLength(LinkQueue Q)
{ QueuePtr p; int n=0;
p=Q.front;
while (p!=Q.rear)
{ n++; p=p->next; }
return n;
}
/* 6、取队头元素 */
ElemType GetHead(LinkQueue Q)
{ if (Q.front!=Q.rear)
return Q.front->next->data;
}
/* 7、入队列 */
void EnQueue(LinkQueue *Q, ElemType e)
{ QueuePtr p;
p=(QueuePtr)malloc(sizeof(QNode));
if (!p) exit(0);
p->data=e; p->next=NULL;
Q->rear->next=p;
Q->rear=p; }
/* 8、出队列 */
void DeQueue(LinkQueue *Q, ElemType *e)
{ QueuePtr p;
if (Q->front!=Q->rear)
{ p=Q->front->next;
*e=p->data;
Q->front->next=p->next;
if (Q->rear==p) Q->rear=Q->front;
free(p); }
}
/* 9、遍历链式队列并输出元素 */
void QueueTraverse(LinkQueue Q)
{ QueuePtr p;
printf("\nQueue: ");
p=Q.front->next;
while (p)
{ printf("%d\t",p->data);
p=p->next;}
}
/* 约瑟夫问题 */
void Joseffer(int n)
{ LinkQueue Q; int i; ElemType x;
InitQueue(&Q);
for(i=1; i<=n; i++)
EnQueue(&Q,i);
while (!QueueEmpty(Q))
{ for(i=1; i<=3; i++)
{ DeQueue(&Q,&x);
if (i!=3)
EnQueue(&Q,x);
else
printf("%5d",x);
}
}
}
/* 主函数 */
main()
{ LinkQueue Q; int i; ElemType x;
InitQueue(&Q);
for(i=2; i<=5; i++)
EnQueue(&Q,i);
printf("len:%d\n",QueueLength(Q));
while (!QueueEmpty(Q))
{ DeQueue(&Q,&x);
printf("%d\t",x); }
//QueueTraverse(Q);
//Joseffer(6);
}
自己去调试吧，这个是C语言版的链式队列，如果看不懂或者调不出来就去看书吧。否则你这门是白学了。
注：这里是链式队列
/***************/
/* 循环队列 */
/***************/
#include "stdlib.h"
#include "stdio.h"
#define N 100
/* 定义循环队列类型 */
typedef int ElemType;
typedef struct
{ ElemType *base;
int front;
int rear;
} SqQueue;
/* 1、初始化循环队列 */
void InitQueue(SqQueue *Q)
{ Q->base=(ElemType*)malloc(N*sizeof(ElemType));
Q->front=Q->rear=0; }
/* 2、销毁循环队列 */
void DestroyQueue(SqQueue *Q)
{ free(Q->base); }
/* 3、清空循环队列 */
void ClearQueue(SqQueue *Q)
{ Q->front=Q->rear=0; }
/* 4、判断空队列 */
int QueueEmpty(SqQueue Q)
{ if (Q.front==Q.rear)
return 1;
else
return 0; }
/* 5、求循环队列长度 */
int QueueLength(SqQueue Q)
{ return (Q.rear+N-Q.front)%N; }
/* 6、取队头元素 */
void GetHead(SqQueue Q, ElemType *e)
{ if (Q.front!=Q.rear)
*e=Q.base[Q.front];
}
/* 7、入队列 */
int EnQueue(SqQueue *Q, ElemType e)
{ if ((Q->rear+1)%N==Q->front)
return 0;
Q->base[Q->rear]=e;
Q->rear=(Q->rear+1)%N;
return 1; }
/* 8、出队列 */
int DeQueue(SqQueue *Q, ElemType *e)
{ if (Q->front==Q->rear)
return 0;
*e=Q->base[Q->front];
Q->front=(Q->front+1)%N;
return 1; }
/* 9、遍历循环队列并输出元素 */
void QueueTraverse(SqQueue Q)
{ int i;
printf("\nQueue: ");
if (Q.rear<Q.front) Q.rear=Q.rear+N;
for(i=Q.front; i<Q.rear; i++)
printf("%d\t",Q.base[i%N]); }
/* 主函数 */
main()
{ SqQueue Q; int i; ElemType x;
InitQueue(&Q);
for(i=2; i<=5; i++)
EnQueue(&Q,i);
printf("len:%d\n",QueueLength(Q));
while (!QueueEmpty(Q))
{ DeQueue(&Q,&x);
printf("%d\t",x); }
QueueTraverse(Q);
}
在给你个循环队列吧
④ 用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为新入出元素）。 队列和栈一样，有着非常广泛的应用。
具体网上查:
另外,虚机团上产品团购,超级便宜
⑤ 数据结构C语言描述的链队列的基本操作（初始化，判空，入队，出队，取对头，输出队列所有值....）
void InitQueue(LiQueue *&q)
{q=(LiQueue *)malloc(sizeof(LiQueue));
q->front=q->rear-NULL;} //初始化
int QueueEmpty(LiQueue *q)
{if(q->rear==NULL)
return 1;
else
return 0;} //判空
void enQueue( LiQueue *&q,ElemType e)
{QNode *s;
s=(QNode *)malloc(sizeof(QNode));
s->data=e;
s->next=NULL;
if(q->rear==NULL)
q->front=q->rear=s;
else
{q->rear->next=s;
q->rear=s;
}} //入队
int deQueue( LiQueue *&q,ElemType &e)
{QNode *t;
if(q->rear==NULL)
return 0;
t=q->front;
if(q->front==q->rear)
q->front=q->rear=NULL;
else
q->front=q->front->next;
e=t->data;
free(t);
return 1;} //出队
int deQueue( LiQueue *&q,ElemType &e)
{QNode *t;
if(q->rear==NULL)
return 0;
t=q->front;
if(q->front==q->rear)
q->front=q->rear=NULL;
else
q->front=q->front->next;
e=t->data;break;
free(t);
return 1;} //取队头
输出队列所有数就是出队
⑥ c语言队列操作
pq->rear->next
=
pnew这个代码从队列的尾部增加新节点，
然后pq->rear
=
pnew更新队列尾部指针。队列的数据结构形式就是由一个头front指针，一个尾rear指针来表征，items的设计是用空间换时间，涉及队列大小的操作会非常方便。
队列的特征是先进先出，你给出的链式实现，其实就跟一个链表一样，链表的添加删除如果能理解了，队列只是链表的元素增加/删除
按先进先出特点的一种实现。
但对于队列来说，实现方式不是重点，先进先出的性质才是重点，这在实际应用中很多，比如排队叫号。