queue c++,关于C语言队列的问题帮我修改一下啊
queue c++,关于C语言队列的问题帮我修改一下啊详细介绍
本文目录一览： c++如何查看queue里面的函数原型
概念：queue是一种先进先出的数据结构。一端插入数据，一端移出数据。
队头：出队 pop
队尾：入队 push
只有队头队尾数据能被访问，不允许有遍历行为
在这里插入图片描述
二、基本接口
①构造函数
函数原型
queue
que; //queue采用模板类实现，queue对象的默认构造形式
queue
<const queue &que); 拷贝构造函数
1
2
1
2
②赋值操作
函数原型
queue& operator=(const queue &que); //重载等号操作符
1
1
③数据存取
函数原型
push(elem); //往队尾添加元素
pop(); //从队头移除第一个元素
back(); //返回最后一个元素
front(); //返回第一个元素
1
2
3
4
1
2
3
4
④大小操作
函数原型
queue
queue是STL中现成的队列容器，我们只需要了解他的相关函数及使用方法，即可很方便的帮助我们使用队列这个数据结构。
1.头文件：
#include < queue >
2.变量声明：
queue < 数据类型 >变量名
例queue < int >a； 即声明了一个int型的队列a
同理，也可声明queue < string > b; queue < struct node > c；
3.相关函数：
(1)q.push(x) ：即向队列q的队尾插入数据x
#include
queue
q;
q.push(5);
cout << q.front() << endl;
1
2
3
1
2
3
(2)q.front()：此函数没有参数，是指返回队首的值(只返回此值，并不从队中删除)
queue
q;
q.push("hello");
q.push("world");
cout << q.front() << endl;
1
2
3
1
2
3
(3)q.pop()：此函数没有参数，指删除队首元素
queue
q;
q.push(5.3);
q.push(8);
cout << q.front() << '\n';
q.pop();
cout << q.front() << '\n';
1
2
3
4
5
6
1
2
3
4
5
6
(4)q.back()：此函数没有参数，返回队尾元素的值
queue
q;
q.push(5.3);
q.push(8);
cout << q.back() << endl;
1
2
3
1
2
3
(5)q.empty()：此函数没有参数，判断队列是否为空，若队空，则返回真（1）
queue
q;
cout << q.empty() << endl;
q.push("3");
cout << q.empty() << endl;
1
2
3
1
2
3
(6)q.size()：此函数没有参数，返回队列元素个数
queue
q;
q.push(5.3);
q.push(8);
cout << q.size() << '\n';
1
2
3
4
1
2
3
4
二、priority_queue
C语言中，队列是什么意思，有什么用途
其主要特点是先进先出，恐怕最主要的是消息队列吧、、、期待下楼有长篇专门介绍的~~~~
队列是一种特殊的线性表。
队列一种可以实现“先进先出”的存储结构，即“一端入，一端出”，队首(front)出队，队尾(rear)入队，若front指向队首，则rear指向队尾最后一个有效元素的下一个元素；若rear指向队尾，则front指向队首第一个有效元素的下一个元素。
队列特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
扩展资料
循环队列各个参数的含义
1、队列初始化front和rear的值都是零,初始化时队列就是空的。
2、队列非空front代表队列的第一个元素rear代表了最后一个有效元素的下一个元素。
3、队列空front和rear的值相等，但是不一定是零。
参考资料来源：百度百科—队列
C语言和queue有关的指令
#include
// malloc, free
#include "queue.h"
struct queue * queue_create(void)
{
struct queue *q = (struct queue *)malloc(sizeof(struct queue));
if (q == NULL) { // malloc failed
return NULL;
}
q->head = dnode_create();
q->tail = dnode_create();
q->head->next = q->tail;
q->tail->prev = q->head;
q->size = 0;
return q;
}
void queue_destroy(struct queue *q)
{
if (q != NULL) {
while (!queue_isempty(q)) {
queue_dequeue(q);
}
dnode_destroy(q->head);
dnode_destroy(q->tail);
free(q);
q = NULL;
}
}
int queue_front(const struct queue * const q)
{
return q->tail->prev->data;
}
void queue_enqueue(struct queue * const q, const int e)
{
struct dnode *dn = dnode_create();
dn->data = e;
struct dnode *tmp = q->head->next;
q->head->next = dn;
dn->prev = q->head;
dn->next = tmp;
tmp->prev = dn;
q->size += 1;
}
int queue_dequeue(struct queue * const q)
{
struct dnode *dn = q->tail->prev;
struct dnode *tmp = dn->prev;
tmp->next = q->tail;
q->tail->prev = tmp;
int ret = dn->data;
dnode_destroy(dn);
q->size -= 1;
return ret;
}
int queue_size(const struct queue * const q)
{
return q->size;
}
int queue_isempty(const struct queue * const q)
{
return q->size > 0 ? 0 : 1;
}
//////////////////////
static void bubble_sort(int * const a, const int n)
{
int swapped = 1;
while (swapped) {
swapped = 0;
for (int i = 1; i < n; i++) {
if (a[i] < a[i - 1]) {
int tmp = a[i];
a[i] = a[i - 1];
a[i - 1] = tmp;
swapped = 1;
}
}
}
}
C语言中链表与队列有什么区别？
C语言的链表与队列是两种不同的概念：
链表是一种数据的存储方式，其保存的数据在内存中是不连续的，采用指针对数据进行访问；队列是一种数据结构，其特点是先进先出，后进后出；
队列的存储方式可以使用线性表进行存储，也可以使用链表进行存储。
SQQUEUE的第一个元素elemtype *elem;其实是指向了一个数组，该数组中存储着类型为elemtype的元素，然后front和rear就标识了队首和队尾元素对应的数组下标。typedef struct _Point{int x,y;}Point;#defineelemtype Point//这个elemtype可以是任意你自己定义的结构，可以是结构体，也可以是简单数据类型elemtype array[10]={0};//这个是队列的数据结构，在这里是一个Point数组SQQUEUE queue={0};queue.elem=array;//这样array中的元素就是queue中的元素了。queue.front=queue.rear=queue.size=0;
C语言 用单链表实现队列
网络答案，已验证：
#include
#include
struct Node
{
int data; /*值域*/
struct Node *next; /*链接指针*/
};
struct queue
{
struct Node *front; /*队首指针*/
struct Node *rear; /*队尾指针*/
};
/*初始化链队*/
void initQueue(struct queue *hq)
{
hq->front=hq->rear=NULL; /*把队首和队尾指针置空*/
}
/*向链队中插入一个元素x*/
void inQueue(struct queue *hq, int x)
{
struct Node *newNode; /*得到一个由newNode指针所指向的新结点*/
newNode=malloc(sizeof(struct Node));
if(newNode==NULL)
{
printf("内存空间分配失败！ ");
exit(1);
}
newNode->data=x; /*把x的值赋给新结点的值域*/
newNode->next=NULL; /*把新结点的指针域置空*/
/*若链队为空，则新结点即是队首结点又是队尾结点*/
if(hq->rear==NULL)
{
hq->front=hq->rear=newNode;
}else
{
/*若链队非空，则依次修改队尾结点的指针域和队尾指针，使之指向新的队尾结点*/
hq->rear=hq->rear->next=newNode;
}
//return;
}
/*从队列中删除一个元素*/
int delQueue(struct queue*hq)
{
struct Node*p;
int temp;
/*若链队为空则停止运行*/
if(hq->front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
temp=hq->front->data;
/*暂存队首元素以便返回*/
p=hq->front;
/*暂存队首指针以便回收队尾结点*/
hq->front=p->next; /*使队首指针指向下一个结点*/
/*若删除后链队为空，则需同时使队尾指针为空*/
if(hq->front==NULL)
{
hq->rear=NULL;
}
free(p); /*回收原队首结点*/
return temp; /*返回被删除的队首元素值*/
}
/*读取队首元素*/
int peekQueue(struct queue *hq)
{ /*若链队为空则停止运行*/
if(hq->front==NULL)
{
printf("队列为空，无法删除！ ");
exit(1);
}
return hq->front->data; /*返回队首元素*/
}
/*检查链队是否为空，若为空则返回1,否则返回0*/
int emptyQueue(struct queue *hq)
{
/*判断队首或队尾任一个指针是否为空即可*/
if(hq->front==NULL)
{
return 1;
}else
{
return 0;
}
}
/*清除链队中的所有元素*/
void clearQueue(struct queue *hq)
{
struct Node *p=hq->front; /*队首指针赋给p*/
/*依次删除队列中的每一个结点，最后使队首指针为空*/
while(p!=NULL)
{
hq->front=hq->front->next;
free(p);
p=hq->front;
}
/*循环结束后队首指针已经为空*/
hq->rear=NULL; /*置队尾指针为空*/
return;
}
int main(int argc,char *argv[])
{
struct queue q;
int a[8]={3,8,5,17,9,30,15,22};
int i;
initQueue(&q);
for(i=0;i<8;i++)
{
inQueue(&q,a[i]);
}
printf("delnode is %d\n",delQueue(&q));
printf("delnode is %d\n",delQueue(&q));
inQueue(&q,68);
printf("peeknode is %d\n",peekQueue(&q));
while(!emptyQueue(&q))
{
printf("%d\n",delQueue(&q));
}
clearQueue(&q);
}
C语言queue如何加锁和解锁
有两种办法：
重载一个queue模板，把锁封装到重载的函数里
每次使用queue的函数的时候加锁，使用完毕后，解锁
C语言用数组实现循环队列的入队出队
#include
#include "Item.h"static Item *q;static int N, head, tail;void QUEUEinit(int maxN){ q = (Item *)malloc((maxN+1)*sizeof(Item)); N = maxN+1; head = N; tail = 0;}int QUEUEempty(){ return (head%N == tail);}void QUEUEput(Item item){ q[tail++] = item; tail = tail%N;}Item QUEUEget(){ head = head %N; return q[head++];}
#include "stdafx.h"
#include
#define N 200 //预设队列大小
int queue[N];
int flag=0; //队列标识 0为不存在，1为存在
int front=0,rear=0; //队列头，队列尾
void creat() //创建队列
{
if(flag==1)
{printf("队列已经存在。");}
else
{
for(int i=0;i<6;i++)
{
printf("输入初始化的第%d数:",i);
scanf("%d",&(queue[i]));
}
rear=5; flag=1;
}
}
void enqueue() //进队列
{
if(flag==0)
{printf("当前还没有队列，请先创建队列：");}
else
{
printf("输入进入队列的元素：");
scanf("%d",&queue[rear+1]);
rear++;
}
}
void gethead() //出队列
{
if(flag==0)
{printf("当前还没有队列，请先创建队列：");}
else
{
printf("出队列的元素：%d",queue[front]);
front++;
printf("\n出列后的队列为：");
for(int i=front;i<=rear;i++)
{printf("%d ",queue[i]);}
}
}
void print() //打印当前队列
{
printf("\n当前队列为：");
for(int i=0;i<=rear;i++)
{
printf("%d ",queue[i]);
}
}
int main()
{
int servse=-1; //服务标识
while(servse!=0)
{
printf("\n1.创建队列\n");
printf("2.元素进队\n");
printf("3.元素出列\n");
printf("4.打印队列\n");
printf("0.退出\n");
printf("选择：");
scanf("%d",&servse);
switch(servse)
{
case 1:creat();break;
case 2:enqueue();break;
case 3:gethead();break;
case 4:print();break;
case 0:return 0;break;
}
}
}
08-12-27 | 添加评论
0
xingzhenlive
你说的是冒泡法排序吧？这个你直接上资源吧里面去吧他里面有提供详细的源代码的！不好意思我就不给你找了！非常抱歉~！
08-12-27 | 添加评论
0
htj1192
#include "stdafx.h"
#include
#define N 200 //预设队列大小
int queue[N];
int flag=0; //队列标识 0为不存在，1为存在
int front=0,rear=0; //队列头，队列尾
void creat() //创建队列
08-12-27 | 添加评论
0
tj568738985
/*顺序队的基本操作*/
#include
#define MaxSize 100
typedef char ElemType;
typedef struct
{
ElemType queue[MaxSize];
int front,rear;
} queuetype;
void initqueue(queuetype *Q)
{
Q->front=Q->rear=-1;
}
void enter(queuetype *Q,ElemType x)
{
if (Q->rear==MaxSize) printf("队列上溢出!\n");
else
{
Q->rear++; /*队尾指针后移*/
Q->queue[Q->rear]=x; /*新元素赋给队尾单元*/
}
}
void delete(queuetype *Q)
{
if (Q->front==Q->rear)
printf("队列为空!\n");
else
Q->front++;
}
ElemType gethead(queuetype *Q)
{
if (Q->front==Q->rear)
printf("队列为空!\n");
else
return(Q->queue[Q->front+1]);
}
int empty(queuetype *Q)
{
if (Q->front==Q->rear) return(1); /*为空,则返回true*/
else return(0); /*不为空,则返回flase*/
}
void display(queuetype *Q)
{
int i;
printf("队列元素:");
for (i=Q->front+1;i<=Q->rear;i++)
printf("%c ",Q->queue[i]);
printf("\n");
}
main()
{
queuetype *qu;
printf("初始化队列qu\n");
initqueue(qu);
printf("队列空:%d\n",empty(qu));
printf("依次入队a,b,c,d元素\n");
enter(qu,'a');
enter(qu,'b');
enter(qu,'c');
enter(qu,'d');
display(qu);
printf("出队一次\n");
delete(qu);
printf("队首元素:%c\n",gethead(qu));
printf("出队一次\n");
delete(qu);
display(qu);
}
//定义一个int型数组que,长度为N(常量切大于2).int que[N];int rear=0,front=0; //队尾 队头判断队列已满：
if((front+1)%N==rear%N) //成立则队列已满判断队列为空
if((rear==front)) //成立则队列空入队(一般在入队前判断队列是否已满)
//将val入队que[front++]=val;front%=N;出队(一般在出队前判断队列是否为空)
rear=(rear+1)%N;下一个要出队的元素(一般先判断是否为空)
que[rear];
关于C语言队列的问题帮我修改一下啊
#include
#include
#define Queuesize 100
typedef int DataType;
typedef struct
{
int front,rear,count;
DataType data[Queuesize];
}CirQueue;
void InitQueue(CirQueue *Q)
{
Q->front=Q->rear=0;
Q->count=0;
}
int QueueFull(CirQueue *Q)
{
return Q->count==Queuesize;
}
void EnQueue(CirQueue *Q,DataType x)
{
if(QueueFull(Q))
printf("Queue overflow");
else
{
Q->data[Q->rear]=x;
Q->rear=(Q->rear+1)%Queuesize;
}
}
void main()
{
int i,j,a[100],x;
CirQueue q1,q2;
InitQueue(&q1);
InitQueue(&q2);
i=j=0; //没有初始化i 和j
for(x=0;x<5;x++)
{
scanf("%d",&a[x]);
if(a[x]%2==1)
{
EnQueue(&q1,a[x]);
i++;
}
else
{
EnQueue(&q2,a[x]);
j++;
}
}
printf("%d,%d\n",i,j);
}
#include
#include
#include
#define Queuesize 100
typedef int DataType;
typedef struct
{
int front,rear,count;
DataType data[Queuesize];
}CirQueue;
void InitQueue(CirQueue *Q)
{
Q->front=Q->rear=0;
Q->count=0;
}
int QueueFull(CirQueue *Q)
{
return Q->count==Queuesize;
}
void EnQueue(CirQueue *Q,DataType x)
{
if(QueueFull(Q))
printf("Queue overflow");
else
{
Q->data[Q->rear]=x;
Q->rear=(Q->rear+1)%Queuesize;
}
}
void main()
{
int i=0,j=0,n,a[100],x;
CirQueue q1,q2;
InitQueue(&q1);
InitQueue(&q2);
printf("Input the max:");
scanf("%d",&n);
printf("input the data:");
for(x=0;x
<n;x++)
{
scanf("%d",&a[x]);
if(a[x]%2==1)
{
EnQueue(&q1,a[x]);
i++;
}
else
{
EnQueue(&q2,a[x]);
j++;
}
}
printf("%d,%d\n",i,j);
}
C语言，用数组实现队列的入队，出队函数编程
for(i=0; i < 9; i++)
a[i] = a[i+1];
a[i] = ...;
你得像这样正向移
这样的话应该符合你的要求：
#include
void add(int queue[],int x);int Top(int queue[]);void del(int queue[]);int end=0;int main(){ int n; scanf("%d",&n);//将要入队列n个元素 int queue[1000]; for(int i=1;i<=n;i++)//输入n个元素 { add(queue,i);//将i加入队列 } //验证加入队列的元素，将队列中的元素按照输入的顺序输出： for( i=1;i<=n;i++) { printf("%d ",Top(queue));//Top函数返回队头元素 del(queue);//删除队头元素 } //验证输出已经出队列后的队列（数组）元素： printf("\n"); for(i=1;i<=n;i++) printf("%d ",queue[i]); printf("\n"); return 0;}void add(int queue[],int x){ queue[++end]=x;}int Top(int queue[]){ return queue[1];//注意，这里的函数始终return queue[1];这里是和将普通数组中的元素输出最大的不同之处。！！！！！！}void del(int queue[]){ for(int i=2;i<=end;i++) { queue[i-1]=queue[i]; } queue[end]=0;//将删除后的地方置0 end--;}
C语言中使用队列
queue.h是LINUX/UNIX系统下面的一个标准头文件，用一系列的数据结构定义了一队列。包括singly-lined list, list, simple queue(Singly-linked Tail queue), tail queue, circle queue五种。我目测你是windows下面的编译器，没有这个头文件很正常。再说你去include目录下搜一下就知道有没有这个头文件了。
C语言木有自带的队列，需要自己实现或者用第三方库。
C++自带！
是C++ 的 STL库，C语言是没有的
如果你用vc，#include
就好了，但是注意要加上using naemspace std；
我是当你用的c++的STL，STL中没有真正的队列和栈，他们都是通过对双端队列的改造得到的，所以包含的文件可能和你想的不一样。而且这些头文件都没有.h结尾！很特别
如果你不是vc，当我没说