D_S 循环队列的基本操作

//  main.cpp

#include <iostream>

using namespace std;

#include "Status.h"

typedef int QElemType;

#include "SqQueue.h"

int main()

{

SqQueue Q;

QElemType e;

InitQueue(Q);

EnQueue(Q,1);

EnQueue(Q,3);

EnQueue(Q,5);

EnQueue(Q,7);

cout<<"\n队头元素为:"<<GetHead(Q,e)<<endl;

cout<<"\n队列中从队头至队尾的元素为:";

QueueTraverse(Q);

cout<<"\n队列的长度为:"<<QueueLength(Q)<<endl;

DeQueue(Q,e);

cout<<"\n出队的元素为:"<<e<<endl;

cout<<"\n出队操作完成之后队列中从队头至队尾的元素为:";

QueueTraverse(Q);

cout<<"\n队列的长度为:"<<QueueLength(Q)<<endl;

return 0;

}

//  Status.h

#ifndef yuan_Status_h

#define yuan_Status_h

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define INFEASIBLE -1

#define OVERFLOW -2

typedef int Status;

#endif

//  SqQueue.h

#ifndef Y_Y_SqQueue_h

#define Y_Y_SqQueue_h

#define MAXQSIZE 100

typedef struct{

QElemType *base;

int front;

int rear;

}SqQueue;

Status InitQueue(SqQueue &Q)

{

Q.base=new QElemType[MAXQSIZE];

if(!Q.base)  exit(OVERFLOW);

Q.front=Q.rear=0;

return OK;

}

Status GetHead(SqQueue Q,QElemType e)

{

e=Q.base[Q.front];

return e;

}

Status QueueLength(SqQueue Q)

{

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

}

Status EnQueue(SqQueue &Q,QElemType e)

{

if ((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;  //尾指针在循环意义上加1后等于头指针,表示满队

Q.base[Q.rear]=e;

Q.rear=(Q.rear+1)%MAXQSIZE;

return OK;

}

Status DeQueue(SqQueue &Q,QElemType &e)

{

if (Q.front==Q.rear) return ERROR;

e=Q.base[Q.front];

Q.front=(Q.front+1)%MAXQSIZE;

return OK;

}

void QueueTraverse(SqQueue Q)

{

int i;

i=Q.front;

while(i!=Q.rear)

{

cout<<Q.base[i]<<"  ";

i=(i+1)%MAXQSIZE;

}

cout<<endl;

}

#endif

时间: 2024-10-03 11:12:26

D_S 循环队列的基本操作的相关文章

C语言实现循环队列(基本操作及图示)

-------------------------------------------- 如果使用顺序表作为队列的话,当处于右图状态则不能继续插入新的队尾元素,否则会因为数组越界而导致程序代码被破坏. 由此产生了由链表实现的循环队列,只有队列未满时才可以插入新的队尾元素. - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

顺序循环队列的基本操作

#include #include #define OK 1 #define ERROR 0 typedef int Status; // Status是函数的类型,其值是函数结果状态代码,如OK等 typedef int QElemType; #define MAXQSIZE 100 // 最大队列长度(对于循环队列,最大队列长度要减1) typedef struct { QElemType *base; // 初始化的动态分配存储空间 int front; // 头指针,若队列不空,指向队列

循环队列的基本操作

主要的功能:1)循环队列的初始化 2)求循环队列的长度 3)循环队列的插入删除操作 4) 判断循环队列是否为空,是否已经满了 5)遍历循环队列 主要的原理: 1)初始化 front = rear = 0; 2)为空  front = rear 3)已满 front=(rear+1)%size 4)  插入 rear = (rear+1)%size 5)删除 front=(front+1)%size 代码如下: /******************************************

数据结构:循环队列及其基本操作的实现

/** * 循环队列 * 队列设置first指针直接指向队列头部元素,tail尾指针指向队列最后一个元素的后一个,即队列中总是预留一个空位 */ class CircleQueue implements Queue<Integer>{ private Integer[] queueArray = null; private int first; private int tail; private int maxSize; public CircleQueue(int max){ this.ma

顺序结构循环队列的基本操作(一)(进队,出队)待优化

#include<stdio.h>#define ElemType int#include<malloc.h>#define MAXSIZE 10typedef struct{ ElemType *data; int front,rear;}Queue;typedef struct BitNode{ ElemType data; struct Bitree *Lchild,*Rchild;}BitNode;Queue Init_queue(Queue Q){ Q.data=(Ele

两种方法实现队满和队空的判断操作(循环队列)

本周的作业要求: 1.给出循环队列的存储结构定义. 2.完成循环队列的基本操作函数. 1)      初始化循环队列: 2)      建立循环队列: 3)      实现入队和出队操作: 4)     采用下面两种方法实现对满和队空的判断操作: 方法一:修改队满条件,浪费一个元素空间,队满时数组中只有一个空闲单元(必做):   方法二:设置标志flag,当front==rear且flag=0时为队空,当front==rear且flag=1时为队满(必做): 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; //队尾

单片机的 FIFO循环队列实现

转自:单片机的FIFO(先入先出)循环队列实现 ////////////////////////////////////////////////////////// // 文件:config.h ////////////////////////////////////////////////////////// #ifndef __CONFIG_H #define __CONFIG_H //这一段无需改动 //This segment should not be modified #ifndef

Java实现循环队列

一.分析 队列是一种先进先出的线性表,它只允许在表的一端进行插入,而在另一端删除元素.允许插入的一端称为队尾,允许删除的一端称为队头. 循环队列是一种以顺序存储结构表示的队列,为了解决“假溢出”问题而将它设计成头尾相接的循环结构,它的基本操作如下: 1.初始化循环队列 2.销毁循环队列 3.清空循环队列 4.检测循环队列是否为空 5.返回循环队列的元素个数 6.返回循环队列头元素 7.向队尾插入元素 8.删除并返回队头元素 9.遍历循环队列 在循环队列中,除了用一组地址连续的存储单元依次存储从队