环形队列c语言

A. c语言环形队列 链表 和数组的区别

队列先进先出 适合用于排序
链表适合用于存储
C的数组就是指针 适合用于查询

B. C语言中队列怎样创建

队列是一种特殊的链表,在你写GET和PUT方法时只需要返回链表的第一个值,把你要输的值放链表的最后就是队列了!!!

C. C语言中循环队列的队满和队空的判断条件各是什么有什么不同

队空时： Q.front == Q.rear;

队满时： Q.front == (Q.rear + 1) % MAXSIZE;

front指向队首元素，rear指向队尾元素的下一个元素。

maxsize是队列长度。

(3)环形队列c语言扩展阅读：

实现的代码：

#include <stdio.h>

#include <malloc.h>

#define MAXSIZE 100 //最大队列长度

#define OK 1

#define ERROR 0

typedef int ElemType;

typedef int Status;

typedef struct {

ElemType *base; //队列空间

int front; //队头指针

int rear; //队尾指针，若队尾不为空，则指向队尾元素的下一个位置

}SqQueue;

//初始化循环队列

Status initQueue(SqQueue &Q) {

Q.base = (ElemType *) malloc(MAXSIZE * sizeof(ElemType)); //申请空间

Q.front = Q.rear = 0; //队空

return OK;

}

//入队

Status enQueue(SqQueue &Q, ElemType e) {

if ((Q.rear + 1) % MAXSIZE == Q.front) return ERROR; //队满，无法添加

Q.base[Q.rear] = e; //插入元素

Q.rear = (Q.rear + 1) % MAXSIZE; //队尾指针+1

return OK;

}

//出队

Status deQueue(SqQueue &Q, ElemType &e) {

if (Q.front == Q.rear) return ERROR; //队空，无法删除

e = Q.base[Q.front]

Q.front = (Q.front + 1) % MAXSIZE; //队头指针+1

return OK;

}

//返回队列长度

Status length(SqQueue &Q) {

return (Q.rear - Q.front + MAXSIZE) % MAXSIZE;

}

D. 用c语言实现删除环形队列第k个元素

楼主你好。
你所指的环形队列在删除元素的时候有什么特殊要求么？比如绕一周就不再删除？
还是说环形队列一定可以找到第k个元素？
我现在假设环形队列一定可以找到第k个元素，如下：
void DeleteIndexedNode(DList* thiz, int k){//删除第k个元素
DNode* iter=thiz->first;
DNode* pIter;
int index;//假设队列从1开始编号
if(!iter)//队列为空，取消删除
return;
//若想绕一周不再删除，上面可以if(!iter || k > thiz->length) return;//若队列为空或超过一周，取消删除

if( k == 1){//若删除首个节点
thiz->first = iter->next;
thiz->last->next = thiz->first;//DList结构若不是双向链表，应该有一个last指针，提高效率
DestroyDNode(iter);//这个是你自己定制的DNode的析构函数
return;
}
//若删除其他节点
do{
pIter = iter;//pIter指向iter前一个节点，用于帮助析构。
iter = iter->next;
index++;
}while(index < k) ;//因为是环形队列，肯定可以找到第k个元素，而且iter不会为NULL
pIter->next = iter->next;//iter的前一个节点的next绕过iter
DestroyDNode(iter);//这个是你自己定制的DNode的析构函数
return;
}

E. 求一个C语言 循环队列的插入 完整程序

（1）编写一个程序，实现顺序环形队列的各种基本运算，并在此基础上设计一个主程序完成如下功能：
（1）初始化队列q；
（2）判断队列q是否非空；
（3）依次进队元素100、909、44、8；
（4）出队一个元素，输出该元素；
（5）输出队列q的元素个数；
（6）依次进队元素-67、55、99、70；
（7）输出队列q的元素个数；
#include<stdio.h>
#include<malloc.h>
#define QUEUE_INIT_SIZE 100
#define QUEUEINCREMENT 10
#define OK 1
#define TURE 1
#define FALSE 0
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
typedef int Status;
typedef int QElemType;
typedef struct
{
QElemType *base;
int front;
int rear;
}SqQueue;

Status InitQueue(SqQueue &Q)
{
Q.base=(QElemType *)malloc
(QUEUE_INIT_SIZE*sizeof(QElemType));
if(!Q.base)
exit(OVERFLOW);
Q.front=Q.rear=0;
return OK;
}
int QueueNumElem(SqQueue Q)
{
return (Q.rear-Q.front)%QUEUE_INIT_SIZE;
}
Status EnQueue(SqQueue &Q,QElemType e)
{
if((Q.rear+1)%QUEUE_INIT_SIZE==Q.front)
return ERROR;
Q.base[Q.rear]=e;
Q.rear=(Q.rear+1)%QUEUE_INIT_SIZE;

return OK;
}
SqQueue DeQueue(SqQueue Q,int e)
{
int i;
if(Q.front==Q.rear)
printf("队为空!\n");
for(i=e;i<Q.rear;i++)
Q.base[i]=Q.base[i+1];
Q.rear--;
return Q;
}
int main()
{
SqQueue Q,Q1;
static int qele=0;
int i,j=0,k=0,m=0;
static int frontd=Q.front;
i=InitQueue(Q);
if(i==1)
printf("队初始化成功!!\n");
else
printf("队初始化失败!!\n");
if(Q.front!=Q.rear)
printf("队不为空!!\n");
else
printf("队为空L!!\n");
printf("输入数据(END of '9999'):");
scanf("%d",&qele);
while(qele!=9999||Q.rear==Q.front)
{
EnQueue(Q,qele);
scanf("%d",&qele);
}
frontd=Q.front;
while(Q.rear!=Q.front)
{
printf(" %d ",Q.base[Q.front]);
Q.front++;
j++;
}
printf("\n");
Q.front=frontd;
printf("输入要出队的元素:");
scanf("%d",&j);
while(Q.front!=Q.rear)
{
if(Q.base[Q.front]==j)
{
printf("%d\n",Q.base[Q.front]);
Q=DeQueue(Q,Q.front);
m++;
break;
}
Q.front++;
}
Q.front=frontd;
while(Q.front!=Q.rear)
{
printf(" %d ",Q.base[Q.front]);
Q.front++;
}
printf("\n");
Q.front=frontd;
printf("队的长度:%d\n",Q.rear-Q.front);
printf("输入数据(END of '9999'):");
scanf("%d",&qele);
while(qele!=9999||Q.rear==Q.front)
{
EnQueue(Q,qele);
scanf("%d",&qele);
}
Q.front=frontd;
printf("队的长度:%d\n",Q.rear-Q.front);
Q.front=frontd;
printf("出队顺序:");
while(Q.rear!=Q.front)
{
printf(" %d ",Q.base[Q.front]);
Q=DeQueue(Q,Q.front);
m++;
}
printf("end\n");
Q.front=0;
Q.rear=m;
while(Q.rear!=Q.front)
{
free(Q.base);
//Q.base++;
Q.front++;
if(Q.rear-1==Q.front)
printf("队已经释放!\n");
}
return 0;
}

F. c语言实现 一个具有MaxLen个单元的环形队列,设计求其中共有多少个元素

#include<iostream.h>
#include<stdlib.h>

#define QElemType int
#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define MAXQSIZE 100

typedef struct{
QElemType *base;
int front;
int rear;
int length;
int maxsize;
}SqQueue;

int InitQueue(SqQueue &Q,int n)
{
Q.base=new QElemType[n];
if(Q.base==0)return 0;
Q.rear=Q.front=0;
Q.length=0;
Q.maxsize=n;
return 1;
}//构造空队列Q

int QueueLength (SqQueue Q){
return (Q.rear -Q.front +MAXQSIZE) % MAXQSIZE;
}//返回Q的元素个数，即队列的长度

int EnQueue(SqQueue &Q,QElemType e)
{
if(Q.length==Q.maxsize)return 0;
Q.base[Q.rear]=e;
Q.rear=(Q.rear++)%Q.maxsize ;
Q.length++;
return 1;
}//插入元素e为Q的新的队尾元素

int DeQueue(SqQueue &Q,QElemType &e)
{
if(Q.length==0)return 0;
e=Q.base[Q.front];
Q.front=(Q.front+1)%Q.maxsize;
Q.length--;
return 1;
}//删除Q的队头元素，用e返回其值

int GetHead(SqQueue Q,QElemType &e)
{
if(Q.length==0)return 0;
e=Q.base[Q.front];
return 1;
}

bool Empty(SqQueue Q)
{
if(Q.length==0)return true;
return false;
}

void print(SqQueue Q)
{
int k=Q.front;
for(int i=1;i<=Q.length;i++)
{
cout<<Q.base[k]<<" ";
k=(k+1)%Q.maxsize;
}
cout<<endl;
}

void main()
{
SqQueue Q;
QElemType e,i;
InitQueue(Q,10);
cout<<"1:输入一队列"<<endl;
cout<<"2:队列的删除"<<endl;
cout<<"3:队列的插入"<<endl;
cout<<"4:返回元素个数"<<endl;
cout<<"5:退出"<<endl;
int s;
cin>>s;
while(s!=5){
switch (s){
case 1:
cout<<"输入6个元素组成队列: ";
for(i=0;i<6;i++)
{
cin>>e;
EnQueue (Q,e);
}
print(Q);
break;
case 2:
if(Empty(Q))
cout<<"要删除的元素不存在";
else
{
GetHead( Q,e);
cout<<"要删除的元素为 :"<<e<<endl;
DeQueue(Q,e);
cout<<"元素删除后的队列为: ";
print(Q);
}
break;
case 3:
cout<<"输入准备插入的元素: ";
cin>>e;
EnQueue(Q,e);
cout<<"插入后的队列为： ";
print(Q); break;
case 4:
cout<<"元素个数为:";
cout<<QueueLength ( Q);
cout<<endl; break;
case 5:
cout<<"退出程序";
//return;
default: cout<<"输入错误，请重新输入!"<<endl;
}
cout<<endl<<"请继续选择:"<<endl;
cin>>s;

}
}

G. 对于一个具有MaxLen个单元的环形队列,求其中共有多少个元素.用C语言实现.

参看下面代码
program ex5_2(input,output);
const max=1000;
type recordtype=record price,content:real end;
var i,j,n,point,tail:longint;
content,change,distance2,<WBR>money,use:real;
price,distance,consume:array[<WBR>0..max] of real;
oil:array [0..max] of recordtype;
begin
write('Input DI,C,D2,P:'); readln(distance[0],content,<WBR>distance2,price[0]);
write('Input N:'); readln(n); distance[n+1]:=distance[0];
for i:=1 to n do
begin
write('Input D[',i,'],','P[',i,']:');
readln(distance[i],price[i])
end;
distance[0]:=0;
for i:=n downto 0 do consume[i]:=(distance[i+1]-<WBR>distance[i])/distance2;
for i:=0 to n do
if consume[i]>content then
begin writeln('No Solution'); halt end;
money:=0; tail:=1; change:=0;
oil[tail].price:=price[0]*2; oil[tail].content:=content;
for i:=0 to n do
begin
point:=tail;
while (point>=1) and (oil[point].price>=price[i]) do
begin
change:=change+oil[point].<WBR>content;
point:=point-1
end;
tail:=point+1;
oil[tail].price:=price[i];
oil[tail].content:=change;
use:=consume[i]; point:=1;
while (use>1e-6) and (point=oil[point].content
then begin use:=use-oil[point].content;
money:=money+oil[point].<WBR>content*oil[point].price;
point:=point+1 end
else begin oil[point].content:=oil[point]<WBR>.content-use;
money:=money+use*oil[point].<WBR>price;
use:=0 end;
for j:=point to tail do oil[j-point+1]:=oil[j];
tail:=tail-point+1;
change:=consume[i]
end;
writeln(money:0:2)
end.

H. 什么是环形队列，采用什么方法实现环形队列

在用数组表示队列时把数组看成是一个环形的，即令数组中的第一个元素紧跟在最末一个单元之后就形成了一个环形队列。

通常采用逻辑上求余数的方法来实现环形队列，假设数组的大小为n,当元素下标i增1时采用i=(i+1)％n来实现。

(8)环形队列c语言扩展阅读：

队列的特点是先进先出，或者后进后出。环状队列在数据结构里称为循环队列。也就是把队列的尾和头接在一起形成一个环，这样当发生假溢出时，尾指针可以跳到数组的开始，重复利用那些已经从队列里删掉的存储单元。

可以用数组和两个指针（头指针和尾指针，但数据类型可以为整形，只是表示指向的含义）组成一个结构体来实现队列。

环形队列是一个可以实现所有结构体且可以提高个人对指针的了解的一个程序。

程序是用codeblock写的，中间碰到了一个又一个的问题，都最终解决了。这个结构可以作为所有结构体的实现的一个模式。写写这些程序可以不断让自己更加深入认识指针，更加熟悉指针的各种使用。

I. C语言中，队列是什么意思，有什么用途

队列是一种特殊的线性表。

队列一种可以实现“先进先出”的存储结构，即“一端入，一端出”，队首(front)出队，队尾(rear)入队，若front指向队首，则rear指向队尾最后一个有效元素的下一个元素；若rear指向队尾，则front指向队首第一个有效元素的下一个元素。

队列特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。

(9)环形队列c语言扩展阅读

循环队列各个参数的含义

1、队列初始化front和rear的值都是零,初始化时队列就是空的。

2、队列非空front代表队列的第一个元素rear代表了最后一个有效元素的下一个元素。

3、队列空front和rear的值相等，但是不一定是零。

J. 用C语言实现删除环形队列第K个元素

楼主你好。
我现在假设环形队列一定可以找到第k个元素，如下：
void DeleteIndexedNode(DList* thiz, int k){//删除第k个元素
DNode* iter=thiz->first;
DNode* pIter;
int index;//假设队列从1开始编号
if(!iter)//队列为空，取消删除
return;
//若想绕一周不再删除，上面可以if(!iter || k > thiz->length) return;//若队列为空或超过一周，取消删除
if( k == 1){//若删除首个节点
thiz->first = iter->next;
thiz->last->next = thiz->first;//DList结构若不是双向链表，应该有一个last指针，提高效率
DestroyDNode(iter);//这个是你自己定制的DNode的析构函数
return;
}
//若删除其他节点
do{
pIter = iter;//pIter指向iter前一个节点，用于帮助析构。
iter = iter->next;
index++;
}while(index < k) ;//因为是环形队列，肯定可以找到第k个元素，而且iter不会为NULL
pIter->next = iter->next;//iter的前一个节点的next绕过iter
DestroyDNode(iter);//这个是你自己定制的DNode的析构函数
return;
}
以上函数可以实现删除第K个元素，有什么问题可以再问我。