六．队列顺序结构的实现程序

最新推荐文章于 2020-04-02 10:49:41 发布
最新推荐文章于 2020-04-02 10:49:41 发布
阅读量1.1k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rain_qingtian/article/details/9980417
版权

说明：

(1)pubuse.h 是几乎所有实验中都涉及到的，包含了一些常量定义，系统函数原型声明和类型

（Status）重定义,结果状态代码等。

（2） 数据结构定义：以Def.h 为文件名；

（3） 基本操作和算法：以Algo.h 为文件名；

（4） 调用基本操作的主程序：以Use.cpp 为文件名。

所以以上四个文件完成一个程序。推荐这种方法，因为这种方法对以后较大的程序起到便利的作用。

（5）为了方便用户特地写了一个CPP1.cpp，为单文件可运行的程序。

/*pubuse.h*/
#include<string>
#include<ctype.h>
#include<malloc.h> /* malloc()等*/
#include<limits.h> /* INT_MAX 等*/
#include <stdio.h> /* EOF(=^Z 或F6),NULL */
#include <stdlib.h> /* atoi() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math. h 中已定义OVERFLOW 的值为3,故去掉此行*/
typedef int Status; /* Status 是函数的类型,其值是函数结果状态代码，如OK 等*/
typedef int Boolean;/* Boolean 是布尔类型,其值是TRUE 或FALSE */
/*Def.h*/
#define MAXQSIZE 5 /* 最大队列长度(对于循环队列，最大队列长度要减1) */
 typedef struct
 {
   QElemType *base; /* 初始化的动态分配存储空间 */
   int front; /* 头指针,若队列不空,指向队列头元素 */
   int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
 }SqQueue;
/*Algo.h*/
Status InitQueue(SqQueue &Q)
 { /* 构造一个空队列Q */
   Q.base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
   if(!Q.base) /* 存储分配失败 */
     exit(OVERFLOW);
   Q.front=Q.rear=0;
   return OK;
 }
 Status DestroyQueue(SqQueue &Q)
 { /* 销毁队列Q,Q不再存在 */
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
   return OK;
 }
 Status ClearQueue(SqQueue &Q)
 { /* 将Q清为空队列 */
   Q.front=Q.rear=0;
   return OK;
 }
 Status QueueEmpty(SqQueue Q)
 { /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
   if(Q.front==Q.rear) /* 队列空的标志 */
     return TRUE;
   else
     return FALSE;
 }
 int QueueLength(SqQueue Q)
 { /* 返回Q的元素个数,即队列的长度 */
   return(Q.rear-Q.front);
 }

 Status GetHead(SqQueue Q,QElemType *e)
 { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
   if(Q.front==Q.rear) /* 队列空 */
     return ERROR;
   *e=*(Q.base+Q.front);
   return OK;
 }
 Status EnQueue(SqQueue &Q,QElemType e)
 { /* 插入元素e为Q的新的队尾元素 */
   if(Q.rear>=MAXQSIZE)
   { /* 队列满，增加1个存储单元 */
     Q.base=(QElemType *)realloc(Q.base,(Q.rear+1)*sizeof(QElemType));
     if(!Q.base) /* 增加单元失败 */
       return ERROR;
   }
   *(Q.base+Q.rear)=e;
   Q.rear++;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { /* 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
   if(Q.front==Q.rear) /* 队列空 */
     return ERROR;
   e=Q.base[Q.front];
   Q.front=Q.front+1;
   return OK;
 }

 Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败 */
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(*(Q.base+i));
     i++;
   }
   printf("\n");
   return OK;
 }

/*Use.cpp*/
/* main3-4.c 顺序队列(非循环),检验bo3-4.c的主程序 */
 #include"pubuse.h"
 typedef int QElemType;
 #include"def.h"
 #include"algo.h"
 void visit(QElemType i)
 {
   printf("%d ",i);
 }
 void main()
 {
   Status j;
   int i,n;
   QElemType d;
   SqQueue Q;
   InitQueue(Q);
   printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   printf("队列长度为：%d\n",QueueLength(Q));
   printf("请输入队列元素个数n: ");
   scanf("%d",&n);
   printf("请输入%d个整型队列元素:\n",n);
   for(i=0;i<n;i++)
   {
     scanf("%d",&d);
     EnQueue(Q,d);
   }
   printf("队列长度为：%d\n",QueueLength(Q));
   printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   printf("现在队列中的元素为: \n");
   QueueTraverse(Q,visit);
   DeQueue(Q,d);
   printf("删除队头元素%d\n",d);
   printf("队列中的元素为: \n");
   QueueTraverse(Q,visit);
   j=GetHead(Q,&d);
   if(j)
     printf("队头元素为: %d\n",d);
   else
     printf("无队头元素(空队列)\n");
   ClearQueue(Q);
   printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   j=GetHead(Q,&d);
   if(j)
     printf("队头元素为: %d\n",d);
   else
     printf("无队头元素(空队列)\n");
   DestroyQueue(Q);
 }

/*CPP1.cpp*/
#include<string>
#include<ctype.h>
#include<malloc.h> /* malloc()等*/
#include<limits.h> /* INT_MAX 等*/
#include <stdio.h> /* EOF(=^Z 或F6),NULL */
#include <stdlib.h> /* atoi() */
#include<io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */
#include<process.h> /* exit() */
/* 函数结果状态代码*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
/* #define OVERFLOW -2 因为在math. h 中已定义OVERFLOW 的值为3,故去掉此行*/
typedef int Status; /* Status 是函数的类型,其值是函数结果状态代码，如OK 等*/
typedef int Boolean;/* Boolean 是布尔类型,其值是TRUE 或FALSE */
 typedef int QElemType;

 #define MAXQSIZE 5 /* 最大队列长度(对于循环队列，最大队列长度要减1) */
 typedef struct
 {
   QElemType *base; /* 初始化的动态分配存储空间 */
   int front; /* 头指针,若队列不空,指向队列头元素 */
   int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */
 }SqQueue;

 Status InitQueue(SqQueue &Q)
 { /* 构造一个空队列Q */
   Q.base=(QElemType *)malloc(MAXQSIZE*sizeof(QElemType));
   if(!Q.base) /* 存储分配失败 */
     exit(OVERFLOW);
   Q.front=Q.rear=0;
   return OK;
 }
 Status DestroyQueue(SqQueue &Q)
 { /* 销毁队列Q,Q不再存在 */
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
   return OK;
 }
 Status ClearQueue(SqQueue &Q)
 { /* 将Q清为空队列 */
   Q.front=Q.rear=0;
   return OK;
 }
 Status QueueEmpty(SqQueue Q)
 { /* 若队列Q为空队列,则返回TRUE,否则返回FALSE */
   if(Q.front==Q.rear) /* 队列空的标志 */
     return TRUE;
   else
     return FALSE;
 }
 int QueueLength(SqQueue Q)
 { /* 返回Q的元素个数,即队列的长度 */
   return(Q.rear-Q.front);
 }
 Status GetHead(SqQueue Q,QElemType *e)
 { /* 若队列不空,则用e返回Q的队头元素,并返回OK,否则返回ERROR */
   if(Q.front==Q.rear) /* 队列空 */
     return ERROR;
   *e=*(Q.base+Q.front);
   return OK;
 }
 Status EnQueue(SqQueue &Q,QElemType e)
 { /* 插入元素e为Q的新的队尾元素 */
   if(Q.rear>=MAXQSIZE)
   { /* 队列满，增加1个存储单元 */
     Q.base=(QElemType *)realloc(Q.base,(Q.rear+1)*sizeof(QElemType));
     if(!Q.base) /* 增加单元失败 */
       return ERROR;
   }
   *(Q.base+Q.rear)=e;
   Q.rear++;
   return OK;
 }

 Status DeQueue(SqQueue &Q,QElemType &e)
 { /* 若队列不空,则删除Q的队头元素,用e返回其值,并返回OK,否则返回ERROR */
   if(Q.front==Q.rear) /* 队列空 */
     return ERROR;
   e=Q.base[Q.front];
   Q.front=Q.front+1;
   return OK;
 }

 Status QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { /* 从队头到队尾依次对队列Q中每个元素调用函数vi()。一旦vi失败,则操作失败 */
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(*(Q.base+i));
     i++;
   }
   printf("\n");
   return OK;
 }

 void visit(QElemType i)
 {
   printf("%d ",i);
 }

 void main()
 {
   Status j;
   int i,n;
   QElemType d;
   SqQueue Q;
   InitQueue(Q);
   printf("初始化队列后，队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   printf("队列长度为：%d\n",QueueLength(Q));
   printf("请输入队列元素个数n: ");
   scanf("%d",&n);
   printf("请输入%d个整型队列元素:\n",n);
   for(i=0;i<n;i++)
   {
     scanf("%d",&d);
     EnQueue(Q,d);
   }
   printf("队列长度为：%d\n",QueueLength(Q));
   printf("现在队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   printf("现在队列中的元素为: \n");
   QueueTraverse(Q,visit);
   DeQueue(Q,d);
   printf("删除队头元素%d\n",d);
   printf("队列中的元素为: \n");
   QueueTraverse(Q,visit);
   j=GetHead(Q,&d);
   if(j)
     printf("队头元素为: %d\n",d);
   else
     printf("无队头元素(空队列)\n");
   ClearQueue(Q);
   printf("清空队列后, 队列空否？%u(1:空 0:否)\n",QueueEmpty(Q));
   j=GetHead(Q,&d);
   if(j)
     printf("队头元素为: %d\n",d);
   else
     printf("无队头元素(空队列)\n");
   DestroyQueue(Q);
 }


Rain-晴天
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【数据结构与算法】队列的C程序实现
03-11
包含顺序队列、链表队列的实现，还有球钟问题的解决代码。
队列的顺序存储结构(循环队列)
weixin_30634661的博客
08-17 156
// c3-3.h 队列的顺序存储结构(循环队列)(见图3.31) #define MAX_QSIZE 5 // 最大队列长度+1 struct SqQueue { QElemType *base; // 初始化的动态分配存储空间 int front; // 头指针，若队列不空，指向队列头元素 int rear; // 尾指针，若队列不空，指向队列尾元素的下一个位置 }; //...
队列----定义和实现
热门推荐
LL-Studio的专栏
05-08 4万+
1、队列的定义 队列(Queue)：也是运算受限的线性表。是一种先进先出(First In First Out ，简称FIFO)的线性表。只允许在表的一端front进行插入，而在另一端rear进行删除。     队首(front) ：允许进行删除的一端称为队首。     队尾(rear) ：允许进行插入的一端称为队尾。 　　 例如：排队购物。操作系统中的作业排队。先进入队列的成员总是先离开
C_栈和队列(ADT)-队列的非循环(无头指针)顺序表示和实现
Cynical丶Gary_博客
08-07 587
队列是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。 顺序队列一次性要分配大量保证够用的空间，效率较高，因为是基于数组的，长度也是固定的。可以实现变长，但是一般代价较高。 队列的数据元素
两种非循环顺序队列的表示和实现（第三章）
但行好事，莫问前程
03-20 338
两种非循环顺序队列的表示和实现 第一种： 存储空间可增，队头元素总在 [0] 单元，所以不必设头指针。它的缺点是元素出队时需要移动大量元素，尤其在队列较长时，效率较低。 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FAL...
队列的基本操作2
小王的博客
10-20 376
1.链式队列 //队列结点结构体 typedef struct QNode { QElemType data;   QNode *next; }*Queueptr; ------------------------------ //指向结点的指针 struct LinkQueue {  Queueptr front,rear; }
栈与队列的顺序存储结构及实现C++语言源程序.doc
07-06
二、栈和队列的顺序存储结构在教材中,我们给出了栈的链表存储结构和队列的链表存储结构及实现,下面给出的是栈的顺序存储结构及实现和队列的顺序存储结构及实现。1．栈的顺序存储结构及实现C++语言源程序。//--------...
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
顺序队列基本运算操作
09-03
本程序共设计了顺序队列需要的的5个基本操作运算，分别是入队，出队，取对头元素，置空队列，输出队列。附带实验报告。
基于JavaScript的数据结构队列动画实现示例解析
01-21
今天给大家介绍一个基于数据结构中的队列的一个动画,在实现这个动画之前呢,还是给大家讲讲,在JavaScript中我们如何实现一个队列. 二 队列 队列是一种列表，不同的是队列只能在末尾插入元素，在队首删除元素。队列...
顺序队列实现源码（C、C++、Java）
01-24
顺序队列实现源码，分别用C、C++、JAVA实现。
顺序队列C程序
10-15
顺序队列
二叉树的链式存储结构及基本操作
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
11-03 8803
#include #include #include/*malloc()等*/ #include/*INT_MAX等*/ #include/*EOF(=^Z或F6),NULL*/ #include/*atoi()*/ #include/*eof()*/ #include/*floor(),ceil(),abs()*/ #include/*exit()*/ /*函数结果状态代码*/ #define
rust 里面 pub mod 和pub use的意思
realHaha
04-02 5221
pub mod 相当于把该mod复制到这个pub mod语句处 再冠以pub pub use 相当于缩短路径(即use本来的意义) 加上 复制该被引入项到这个pub use语句处 再冠以pub 简单记法: 复制 冠以pub ...
线性表的顺序存储与基本操作
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
10-15 4224
文件名的标识基本以每个实验的内容作为依据，如顺序表的存储结构定义文件为SeqListDef.h。这些程序文件主要包含了如下4类： （1）   pubuse.h   是几乎所有实验中都涉及到的，包含了一些常量定义，系统函数原型声明和类型（Status）重定义,结果状态代码等。 （2）   数据结构定义：以____Def.h为文件名； （3）   基本操作和算法：以____Algo.h为文件名；
线性表的链式存储与基本操作
离开实践的理论是空洞的理论,没有理论指导的实践是盲目的实践
10-15 6650
利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行如下操作：   初始化一个带表头结点的空链表；   创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接的关系。又分为逆位序(插在表头)输入n个元素的值和正位序(插在表尾)输入n个元素的值；   插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链表中
【数据结构】在运行循环队列的顺序表示是基本操作程序时出现错误：“QueueTraverse”: 不能将参数 2 从“QElemType”转换为“int (__cdecl *)(QElemType)”
qq_42704924的博客
12-05 1977
在运行循环队列的顺序表示是基本操作程序时出现错误：“QueueTraverse”: 不能将参数 2 从“QElemType”转换为“int (__cdecl *)(QElemType)” 请大家指教！ 定义时：Status QueueTraverse(SqQueue *Q,void((*visit)(QElemType e)) ) 调用时：QueueTraverse(&amp;Q,d); 完整...
队列的实现
weixin_33772645的博客
07-30 200
一、顺序队列 [cpp] view plaincopy typedef int QElemType; // c3-3.h 队列的顺序存储结构(可用于循环队列和非循环队列) #define MAXQSIZE 5 // 最大队列长度(对于循环队列，最大队列长度要减1) struct SqQueue { ...
队列的基本操作！
追
01-08 2万+
1.链式队列 //队列结点结构体 typedef struct QNode { QElemType data;   QNode *next; }*Queueptr; ------------------------------ //指向结点的指针 struct LinkQueue {  Queueptr front,rear; } [cpp] view plain
页面置换六种算法c语言实现程序
最新发布
12-30
页面置换算法是操作系统中用于管理内存分配的重要算法之一。常见的页面置换算法有六种：最佳置换算法（OPT）、先进先出算法（FIFO）、最近最久未使用算法（LRU）、时钟置换算法（CLOCK）、最不常用算法（LFU）和最近最常用算法（MFU）。 用C语言实现这六种页面置换算法可以通过模拟内存的分配和释放过程来完成。例如，对于FIFO算法，可以使用一个队列来模拟内存中页面的存储和访问顺序，然后根据队列的先进先出特性来进行页面的置换操作。而对于LRU算法，则需要使用链表等数据结构来记录每个页面的访问时间，然后根据最近最少使用的页面进行置换。 具体实现时，可以先定义一个表示内存的数据结构，包括内存的大小、已经占用的页面数等信息。然后根据每种算法的逻辑，编写对应的置换函数，实现页面置换的具体过程。在模拟内存分配和释放的过程中，可以输出每次置换后的内存状态，以便观察不同算法的性能和效果。 当然，为了更好地理解和实现这六种算法，还需要对操作系统的内存管理原理有一定的了解，以及对C语言的数据结构和算法有一定的掌握。通过不断调试和优化程序，可以更深入地理解这些页面置换算法的原理和实现方式。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值