数据结构之循环队列(C++版)

#include <iostream>
#include <stdlib.h>
#include <string>
#define MAXLISTSIZE 100 //预设的存储空间最大容量

using namespace std;
typedef string ElemType;
typedef struct
{
ElemType *elem; //存储空间基址
int rear; //队尾指针
int front; //队头指针
int queuesize; //允许的最大存储空间，以元素为单位
}Queue;

void InitQueue(Queue &Q);
void DestroyQueue(Queue &Q);
void EnQueue(Queue &Q);
void DeQueue(Queue &Q);
void GetElem(Queue Q);
void QueueLength(Queue Q);
void QueueEmpty(Queue Q);
void QueueFull(Queue Q);

int main(void)
{
Queue Q;
int z;
cout << "+---------------------------+" << ‘\n‘;
cout << "|---------循环队列----------|" << ‘\n‘;
cout << "+---------------------------+" << ‘\n‘;
cout << "提示：为保证您的操作得到保存，请按正常顺序退出系统^_^" << ‘\n‘;
do
{
cout << ‘\n‘ << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"--------------------------------" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ 主菜单 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+--------------------------------" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [1]----循环队列初始化 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [2]----循环队列的销毁 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [3]----循环队列的入队 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [4]----循环队列的出队 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [5]----循环队列的存取 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [6]----循环队列的长度 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [7]----循环队列的判空 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [8]----循环队列的判满 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"+ [0]----退出系统 |" << ‘\n‘;
cout << ‘\t‘ << ‘\t‘ << ‘\t‘ <<"--------------------------------" << ‘\n‘;
cout << "请输入您的选择：";
cin >> z;
switch(z)
{
case 0 : break;
case 1 : InitQueue(Q);break;
case 2 : DestroyQueue(Q);break;
case 3 : EnQueue(Q);break;
case 4 : DeQueue(Q);break;
case 5 : GetElem(Q);break;
case 6 : QueueLength(Q);break;
case 7 : QueueEmpty(Q);break;
case 8 : QueueFull(Q);break;
default:cout << "无效选项!" << ‘\n‘;system("pause");
}
}
while(z!= 0);
}

void InitQueue(Queue &Q)
{
//构造一个最大存储空间为 maxsize 的空队列 Q
int maxsize;
cout << "请输入顺序队列的最大存储空间：";
cin >> maxsize;
if(maxsize == 0)
maxsize = MAXLISTSIZE;
Q.elem = new ElemType[maxsize]; //为循环队列分配存储空间
if(!Q.elem)
{
cout << "存储分配失败" << endl; //存储分配失败
system("pause");
return;
}
Q.queuesize = maxsize;
Q.front = Q.rear = 0;
system("pause");
}//InitQueue

void DestroyQueue(Queue &Q)
{
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
delete[] Q.elem;
Q.queuesize = 0;
cout << "循环队列已销毁" << endl;
system("pause");
}

void EnQueue(Queue &Q)
{
ElemType e;
int n, j;
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
if((Q.rear + 1) % Q.queuesize == Q.front)
{
cout << "该队列已满，无法入队" << endl;
system("pause");
return;
}
cout << "请输入入队元素个数(元素个数小于等于" << Q.queuesize - ((Q.rear-Q.front+Q.queuesize) % Q.queuesize) -1 << "): " ;
cin >> n;
cout << "请输入入队的元素：";
for(j = 0; j < n; j++)
{
cin >> e;
Q.elem[Q.rear] = e;
Q.rear = (Q.rear+1) % Q.queuesize;
}
system("pause");
}

void DeQueue(Queue &Q)
{

ElemType e;
int n, j;
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
if (Q.front == Q.rear)
{
cout << "队为空，无法出队" << endl;
system("pause");
return;
}
cout << "请输入出队元素个数(元素个数小于等于" << ((Q.rear-Q.front+Q.queuesize) % Q.queuesize) << "): ";
cin >> n;
cout << "出队的元素为: ";
for(j = 0; j < n; j++)
{
e = Q.elem[Q.front];
cout << e << ‘ ‘;
Q.front = (Q.front+1) % Q.queuesize;
}
cout << endl;
system("pause");
}

void GetElem(Queue Q)
{
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
if (Q.front == Q.rear)
{
cout << "队列为空，无法获取队首元素" << endl;
system("pause");
return;
}
cout << Q.elem[Q.front] << endl;
system("pause");
}

void QueueLength(Queue Q)
{
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
cout << "循环队列的长度：" << ((Q.rear-Q.front+Q.queuesize) % Q.queuesize) << endl;
system("pause");
}

void QueueEmpty(Queue Q)
{
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
if (Q.front == Q.rear)
cout << "队列为空" << endl;
else
cout << "队列不为空" << endl;
system("pause");
return;
}

void QueueFull(Queue Q)
{
if(Q.queuesize == 0)
{
cout << "队列已销毁，请选择1初始化栈" << endl;
system("pause");
return;
}
if ((Q.rear + 1) % Q.queuesize == Q.front)
cout << "该队列已满" << endl;
else
cout << "该队列未满" << endl;
system("pause");
return;
}

时间： 2024-11-13 00:58:57

数据结构之循环队列(C++版)的相关文章

基本数据结构，循环队列的顺序实现。

队列是一种先进先出的数据结构,这里用顺序结构将其实现. 1.首先用结构体定义一个队列,front指向队首元素的前面一位,real指向队尾元素. 1 //队列的结构定义 2 #define MAX 6 3 typedef struct { 4 int front,real; 5 int data[MAX]; 6 }queue; 2.创建一个循环队列,初始化令front=real=0,因为当队列满时也有front=real,此时无法判断队满:所以我们弃置一个元素位不用,其位置随机,所以队列的实际最大

数据结构之循环队列c语言实现

    队列是一种先入先出的结构,数据从队列头出,队尾进.在linux内核中进程调度,打印缓冲区都有用到队列.     队列有多种实现方式,可以用链表,也可以用数组.这里用数组来实现一个简单的循环队列.首先创建一个大小为8的队列如下,队列头尾指针指向同一块内存,          当从队列尾部插入一个数据后变成下面的情形,为了便于处理,这里始终会浪费一个空间 继续插入数据,直到出现以下情形,表示队列满了, 接下来看一下出队的情形,从队列头出队3个元素, 再添加三个元素后队列又变成满的了, 在上面

数据结构--顺序循环队列和链式队列

第一部分:顺序循环队列的实现 1 //循环队列的实现 2 #define OK 1 3 #define MAXSIZE_Q 10 4 //#define OVERFLOW -2 5 #define ERROR 0 6 7 typedef int Status; 8 typedef int QElemtype; 9 10 typedef struct{ 11 QElemtype *base; //初始化的动态分配存储空间 12 int front; //队头指针 13 int rear; //队尾

数据结构：循环队列（C语言实现）

生活中有非常多队列的影子,比方打饭排队,买火车票排队问题等,能够说与时间相关的问题,一般都会涉及到队列问题:从生活中,能够抽象出队列的概念,队列就是一个能够实现"先进先出"的存储结构.队列分为链式队列和静态队列:静态队列一般用数组来实现,但此时的队列必须是循环队列,否则会造成巨大的内存浪费:链式队列是用链表来实现队列的.这里讲的是循环队列,首先我们必须明确以下几个问题 一.循环队列的基础知识 1.循环队列须要几个參数来确定 循环队列须要2个參数,front和rear 2.循环队列各个參

数据结构：循环队列

数组表示的问题 对于队列最好的方法是使用链表实现,因为对于数组来说,队列可能会出现下面这种情况: 如图所示,不可以继续添加元素,否则会造成数组越界而遭致程序出错.然而此时又不应该扩充数组,因为还有大量实际空间未被占用. 此时我们应该如何解决这个问题呢?我们将其实现为循环队列. 理解循环队列 何谓循环队列?首先我们要说明的是循环队列仍然是基于数组实现的.但是为了形象化的说明问题,我们如下图所示 1.图中有两个指针(其实就是两个整数型变量,因为在这里有指示作用,所以这里理解为指针)front.rea

数据结构学习(循环队列)

1. 尾索引的下一个为头索引时表示队列满,即将队列容量空出一个作为约定 2. 这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front [满] rear == front [空] package cn.imut; //循环队列 import java.util.Scanner; public class CircleArrayQueueDemo { public static void main(String[] args) { System.out.prin

【 数据结构 】循环队列

队列是先进先出(first in first out)的线性表,简称 FIFO. 假设循环队列: 队头:front 队尾:rear 最大尺寸:queue size 队列满:(rear + 1)% queue size == front 通用队列长度计算: (rear - front + queue size)% queue size 存储结构代码示例 typedef int QElemType; /* 队列内数据的类型 */ /* 循环队列的顺序存储结构 */ typedef struct {

【数据结构】循环队列的实现（c++）

头文件: #pragma once #include <iostream> #include <assert.h> using namespace std; template<class Type> class CQueue { public: CQueue(size_t sz = INIT_SZ); ~CQueue(); public: bool full()const; bool empty()const; void show()const; bool push(c

顺序循环队列的c语言实现

1. 循环队列的顺序存储结构 typedef struct { QElemType data[MAXSIZE]; int front; /* 头指针 */ int rear; /* 尾指针,若队列不空,指向队列尾元素的下一个位置 */ }SqQueue; 2. 初始化一个空队列Q Status InitQueue(SqQueue *Q) { Q->front=0; Q->rear=0; return OK; } 3.将Q清为空队列 Status ClearQueue(SqQueue *Q) {