c语言顺序队列
‘壹’ c语言实现一个优先队列
#include <stdio.h>
#include <stdlib.h>
//数据列表结点结构体
typedef struct ListNode
{
int ndata;
int npriority;
struct ListNode *pNext;
};
//数据列表结构体
typedef struct DataList
{
ListNode *pHead;
ListNode *pLast;
int arPriorityInfoStore[11];
};
//生成链表变初始化，使用数据队列首先调用
DataList *CreateList()
{
int i;
//内存申请
DataList *list = (DataList*)malloc(sizeof(DataList));
//结构体初始化
list->pHead = list->pLast = 0;
for(i=0;i<11;i++)
{
list->arPriorityInfoStore[i] = 0;
}
return list;
}
/*!数据入队
* 参数list：数据队列链表
* 参数data：待入队的数据
* 参数prt ：待入队数据的优先级
* 返回值：布尔型，true为入队成功，false失败
*/
bool Insert(DataList *list,int data, int prt)
{
//内存申请
ListNode *pNewNode = (ListNode *)malloc(sizeof(ListNode));
//内在申请失败，无法入队
if(pNewNode = 0)
return false;
//新结点初始化
pNewNode->ndata = data;
pNewNode->npriority = prt;
pNewNode->pNext = 0;
list->arPriorityInfoStore[prt]++;
//区别对待第一个结点
if(list->pHead == 0)
{
list->pHead = list->pLast = pNewNode;
}
else
{
list->pLast->pNext = pNewNode;
list->pLast = pNewNode;
}
}
/*! 数据出队
* 参数list：数据队列链表
* 返回值：整型，优先最大的数据
*/
int Pop(DataList *list)
{
int nMaxPriority;
ListNode *pCursortNode;
//找出队列中的最大优先级
for(nMaxPriority = 10; nMaxPriority >= 0; nMaxPriority--)
{
if(list->arPriorityInfoStore[nMaxPriority]>0)
break;
}
//由于数据有效范围为0到100,故取-1作为无效值表示此时列表为空
if(nMaxPriority < 0)
return -1;
//找到优先级最大的点，取值返回
for(pCursortNode = list->pHead; pCursortNode->pNext!=0; pCursortNode = pCursortNode->pNext)
{
if(pCursortNode->npriority != nMaxPriority)
continue;
else
break;
}
return pCursortNode->ndata;
}
未进行测试，也未写主函数。功能函数已经写出，可能中间会有小问题，你调一下即能使用。
‘贰’ 浜岀骇c璇瑷锛岄槦鍒椼佸惊鐜阒熷垪鏄浠涔
阒熷垪鏄涓绉岖壒娈婄殑绾挎ц〃锛屽惊鐜阒熷垪鏄灏嗗悜閲忕┖闂存兂璞′负涓涓棣栧熬鐩告帴镄勫浑鐜銆
1銆侀槦鍒楁槸涓绉岖壒娈婄殑绾挎ц〃锛岀壒娈娄箣澶勫湪浜庡畠鍙鍏佽稿湪琛ㄧ殑鍓岖锛坒ront锛夎繘琛屽垹闄ゆ搷浣滐纴钥屽湪琛ㄧ殑钖庣锛坮ear锛夎繘琛屾彃鍏ユ搷浣滐纴鍜屾爤涓镙凤纴阒熷垪鏄涓绉嶆搷浣滃弹闄愬埗镄勭嚎镐ц〃銆
2銆佸惊鐜阒熷垪鏄灏嗗悜閲忕┖闂存兂璞′负涓涓棣栧熬鐩告帴镄勫浑鐜锛屽苟绉拌繖绉嶅悜閲忎负寰鐜钖戦噺銆傚瓨鍌ㄥ湪鍏朵腑镄勯槦鍒楃О涓哄惊鐜阒熷垪銆鍦ㄩ‘搴忛槦鍒椾腑锛屽綋阒熷熬鎸囬拡宸茬粡鍒版暟缁勭殑涓婄晫锛屼笉鑳藉啀链夊叆阒熸搷浣滐纴浣嗗叾瀹炴暟缁勪腑杩樻湁绌轰綅缃锛岃繖灏卞彨锅气滃亣婧㈠嚭钬濓纴瑙ｅ喅锅囨孩鍑虹殑阃斿缎----閲囩敤寰鐜阒熷垪銆
镓╁𪾢璧勬枡
鍒ゆ柇阒熷垪婊＄殑𨱍呭喌锛
1銆乧ount𨱒ヨ℃暟锛涢氩父浣跨敤count
Count绛変簬阒熷垪镄凪AXSIZE
2銆丗lag镙囧织 int
鍏ラ槦鍒 flag=1 鍑洪槦鍒梖lag=0
Front=rear&&flag==0
3銆佹妸涓涓瀛桦偍鍗曞厓绌哄嚭𨱒ワ纴涓嶅瓨鏀炬暟鎹
Rear+1==front
娉ㄦ剰浜嬮”锛氾纸涓嶈侊级 椤哄簭缁撴瀯锛孲eqQueue myQueue锛
鍙傝冭祫鏂欐潵婧愶细锏惧害锏剧戋斿惊鐜阒熷垪
‘叁’ 数据结构c语言版，出队入队及依次输出一个队列的操作。
#include<stdio.h>
#include<stdlib.h>
#defineElemTypeint
#defineStatusint
#defineOK1
#defineERROR0
typedefstructQNode{
ElemTypedata;
structQNode*next;
}QNode;
typedefstructLinkQueue{
QNode*front;
QNode*rear;
}LinkQueue;
StatusInitQueue(LinkQueue*q){//建立队列
q->front=q->rear=(QNode*)malloc(sizeof(QNode));
if(!q->front)
returnERROR;
q->front->next=NULL;
returnOK;
}
StatusEnQueue(LinkQueue*q,ElemTypee){//入队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p->data=e;
p->next=NULL;
q->rear->next=p;//入队操作，从队尾(rear)进入
q->rear=p;
returnOK;
}
StatusDeQueue(LinkQueue*q,ElemType*e){//出队
QNode*p=(QNode*)malloc(sizeof(QNode));
if(!p)
returnERROR;
p=q->front->next;//q指向的是front指针的下一个位置，亦即队首元素
*e=p->data;
q->front->next=p->next;//出队操作后，front++
if(q->rear==p)//判断是否全部出队
q->rear=q->front;//如果全部出队，则将队列置为空
returnOK;
}
StatusPrintfQueue(LinkQueue*Q){
QNode*p;
for(p=Q->front->next;p!=NULL;p=p->next)
printf("%d ",p->data);
}
intmain(void)
{
inti,n;
ElemTypee,de;
LinkQueue*q=(LinkQueue*)malloc(sizeof(QNode));
if(!q)
returnERROR;
InitQueue(q);
printf("以下开始构造初始队列: ");
printf("请输入元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("初始队列构造完毕！ ");
printf("初始队列： ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行入队操作: ");
printf("请输入需入队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i){
printf("请输入第%d个元素：",i+1);
scanf("%d",&e);
EnQueue(q,e);
}
printf(" ");
printf("入队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
printf("以下开始执行出队操作: ");
printf("请输入需出队的元素个数：");
scanf("%d",&n);
printf(" ");
for(i=0;i<n;++i)
DeQueue(q,&de);
printf(" ");
printf("出队%d个元素操作完毕！ ",n);
printf("此时队列: ");
PrintfQueue(q);
printf(" ");
printf("====================================================== ");
free(q);
return0;
}
执行结果
‘肆’ 数据结构c语言版，出队入队及依次输出一个队列的操作。
黑色的提示框是程序运行结果窗口，不是错误的窗口
代码错误说明敏戚如下：
while(Q->front!=Q->rear)//在本循环体之中，Q->frontQ->rear的值始终没有变化
//故而在这里肯定是一个死循环
{
printf("%d,",Q->front->next->data);
Q->front->next=Q->front->next->next;
}
//改正后的代码如下：
QNode*s=Q->front;
while(s!=Q->rear)
{
printf("%d,",s->data);
s=s->next;
}
另外，所有的函数当中不应该有exit
exit是一个系统函桥毕陵数，表示结束程序，而不是退出函数
如果需要退出函数帆数可以使用return来达到该目的
‘伍’ c语言队列排序要用什么什么算法
可以调用 系统函数
可以使用 快排 qort 函数 (头文件stdlib,h里面)，
只需要自己编写 比较函数
int cmp(const void *p1, const void *p2)
{
}
可以网络一下用法 ， 很详细的！
当然可以自己写 排序函数 快排 堆排序 。。。。 冒泡 和选择的 效率就很低了
http://ke..com/view/982231.htm
‘陆’ 用C语言编写队列程序
#include<stdio.h>
#include<stdlib.h>
#include<malloc.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语言）队列
对顺序循环队列，常规的设计方法是使用队尾指针和队头指针，队尾指针用于指出当前胡队尾位置下标，队头指针用于指示当前队头位置下标。现要求：
（1）设计一个使用队头指针和计数器胡顺序循环循环队列抽象数据类型，其中包括：初始化，入队列，出队列，取队头元素肯判断队列是否非空；
#include"stdio.h"
#include"malloc.h"
#include"stdlib.h"
#include"conio.h"
#defineMAX80
typedefstruct
{
intdata[MAX];
intfront,rear;
intnum;
}SeQue;
SeQue*Init_SeQue()
{
SeQue*s;
s=newSeQue;
s->front=s->rear=MAX-1;
s->num=0;
returns;
}
intEmpty_SeQue(SeQue*s)
{
if(s->num==0)
return1;
else
return0;
}
intIn_SeQue(SeQue*s,intx)
{
if(s->num==MAX)
return0;
else
{
s->rear=(s->rear+1)%MAX;
s->data[s->rear]=x;
s->num++;
return1;
}
}
intOut_SeQue(SeQue*s,int*x)
{
if(Empty_SeQue(s))
return0;
else
{
s->front=(s->front+1)%MAX;
*x=s->data[s->front];
s->num--;
return1;
}
}
voidPrint_SeQue(SeQue*s)
{
inti,n;
i=(s->front+1)%MAX;
n=s->num;
while(n>0)
{printf("%d",s->data[i]);
i=(i+1)%MAX;
n--;
}
}
voidmain()
{
SeQue*s;
intk,flag,x;
s=Init_SeQue();
do{
printf("\");
printf("\t\t\t循环顺序队列");
printf("\t\t\t***********************");
printf("\t\t\t**1-入队**");
printf("\t\t\t**2-出队**");
printf("\t\t\t**3-判队空**");
printf("\t\t\t**4-队列显示**");
printf("\t\t\t**0-返回**");
printf("\t\t\t***********************");
printf("\t\t\t请输入菜单项(0-4):");
scanf("%d",&k);
switch(k)
{
case1:
printf("请输入入队元素:");
scanf("%d",&x);
flag=In_SeQue(s,x);
if(flag==0)
printf("队满不能入队!按任意键返回..");
else
printf("元素已入队!按任意键返回..");
getch();
system("cls");
break;
case2:
flag=Out_SeQue(s,&x);
if(flag==0)
printf("队列空出队失败!按任意键返回..");
else
printf("队列头元素已出队~!按任意键返回..");
getch();
system("cls");
break;
case3:
flag=Empty_SeQue(s);
if(flag==1)
printf("该队列为空!按任意键返回..");
else
printf("该队列不为空!按任意键返回..");
getch();
system("cls");
break;
case4:
printf("该队列元素为:");
Print_SeQue(s);
printf("按任意键返回..");
getch();
system("cls");
break;
}
}while(k!=0);
}
‘捌’ c语言数据结构（循环队列，用顺序结构）
c++
//bc_queue.h
class Queue {
public:
virtual BOOLEAN is_empty(void)=0;
virtual BOOLEAN is_que_full(void)=0;
virtual void build_que(DATA_TYPE str[])=0;
virtual void add_que(DATA_TYPE)=0;
virtual DATA_TYPE del_from_que(void)=0;
virtual int get_que_siz(void)=0;
virtual void print_que(void)=0;
};
//Ary_Circ_Que.h
class Array_Circ_Queue:public Queue{
private:
int QUEUE_SIZ;
int front_of_queue, rear_of_queue;
DATA_TYPE *circ_queue;
void init_ary_circ_que(void);
public:
Array_Circ_Queue(int que_siz);
~Array_Circ_Queue();
BOOLEAN is_empty(void);
BOOLEAN is_que_full(void);
void build_que(DATA_TYPE str[]);
void add_que(DATA_TYPE); //put
DATA_TYPE del_from_que(void); //get
inline int get_que_siz(){return (QUEUE_SIZ);}
void print_que(void);
};
//Ary_Circ_Que.cpp
//
#include<stdio.h>
typedef int BOOLEAN;
const int UNDERFLOW=-1;
typedef char DATA_TYPE;
#include "bc_queue.h"
#include "Ary_Circ_Que.h"
Array_Circ_Queue::Array_Circ_Queue(int que_siz)
{
circ_queue=new DATA_TYPE[QUEUE_SIZ=que_siz];
init_ary_circ_que();
}
Array_Circ_Queue::~Array_Circ_Queue()
{
delete []circ_queue;
}
void Array_Circ_Queue::init_ary_circ_que(void)
{
front_of_queue=QUEUE_SIZ;
rear_of_queue=QUEUE_SIZ;//maximum size
}
BOOLEAN Array_Circ_Queue::is_empty(void)
{
return ((front_of_queue==QUEUE_SIZ)&&(rear_of_queue==QUEUE_SIZ));
}
BOOLEAN Array_Circ_Queue::is_que_full(void)
{
return (((rear_of_queue==0)&&(front_of_queue==QUEUE_SIZ))||(rear_of_queue==(front_of_queue+1)));
}
void Array_Circ_Queue::add_que(DATA_TYPE new_data)
{
if(!is_que_full()){
if(rear_of_queue<=0)
rear_of_queue=QUEUE_SIZ;
if(is_que_empty())
--front_of_queue;
circ_queue[--rear_of_queue]=new_data;
}
else
printf("\n add_que: queue overflow\n");
}
DATA_TYPE Array_Circ_Queue::del_from_que(void)
{
if(!is_que_empty()){
if(front_of_queue<0)
front_of_queue=QUEUE_SIZ;
return (circ_queue[front_of_queue--]);
}
else
{
printf("\n del_que: %s ","queue underflow"):
return (UNDERFLOW);
}
}
void Array_Circ_Queue::build_que(DATA_TYPE str[])
{
if(str[0]=='\0')
printf("\n build_que:empty string \n");
else
for(int j=0;str[j]!='\0';++j)
add_que(str[j]);
}
void Array_Circ_Queue::print_que(void)
{
if(is_que_empty()){
if((rear_of_queue<front_of_queue)&&(rear_of_queue>=0)){
printf(" c_queue[%i]=%c <-queue front\n ",front_of_queue,circ_queue[front_of_queue]);
for(int i=front_of_queue-1;i>=0;i--)
printf(" c_queue[%i]=%c \n",i,circ_queue[i]);
for(i=QUEUE_SIZ-1;i<=rear_of_queue;i--)
printf(" c_queue[%i]=%c \n",i,circ_queue[i]);
}
else{
//case:rear>0&&front<=rear
if(rear_of_queue>0)
printf(" c_queue[%i]=%c <-queue front\n ",front_of_queue,circ_queue[front_of_queue]);
for(int i=front_of_queue-1;(i>=0&&i<=rear_of_queue);i--)
printf(" c_queue[%i]=%c \n",i,circ_queue[i]);
}
else
printf("\n no element in queue.\n");
}
‘玖’ C语言中，队列是什么意思，有什么用途
队列是一种特殊的线性表。
队列一种可以实现“先进先出”的存储结构，即“一端入，一端出”，队首(front)出队，队尾(rear)入队，若front指向队首，则rear指向队尾最后一个有效元素的下一个元素；若rear指向队尾，则front指向队首第一个有效元素的下一个元素。
队列特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
(9)c语言顺序队列扩展阅读
循环队列各个参数的含义
1、队列初始化front和rear的值都是零,初始化时队列就是空的。
2、队列非空front代表队列的第一个元素rear代表了最后一个有效元素的下一个元素。
3、队列空front和rear的值相等，但是不一定是零。