【数据结构】顺序队列的实现(c++)

头文件:

#pragma once

#include <iostream>
#include <assert.h>
using namespace std;

template<class Type>
class SeqQueue
{
public:
	SeqQueue(size_t sz = INIT_SZ);
	~SeqQueue();
public:
	bool empty()const;
	bool full()const;
	void show()const;
	bool push(const Type &x);
	bool pop();
	void gettop(Type &x);
	int length()const;
	void clear();
	void destory();
	void quit_system(Type &x);
private:
	enum{ INIT_SZ = 8 };
	Type *base;
	int capacity;
	int head;
	int tail;
};

template<class Type>
SeqQueue<Type>::SeqQueue(size_t sz = INIT_SZ)
{
	capacity = sz > INIT_SZ ? sz : INIT_SZ;
	base = new Type[capacity];
	assert(base != NULL);
	head = 0;
	tail = 0;
}

template<class Type>
SeqQueue<Type>::~SeqQueue()
{
	destory();
}

// 判断队列是否满了,顺序队列呈现虚满的状态
template<class Type>
bool SeqQueue<Type>::full()const
{
	return (tail >= capacity);
}

// 判断队列是否为空
template<class Type>
bool SeqQueue<Type>::empty()const
{
	return (tail == 0);
}

// 显示
template<class Type>
void SeqQueue<Type>::show()const
{
	if (tail == 0)
	{
		cout << "the queue is empty!" << endl;
		return;
	}
	for (int i = tail - 1; i >= head; --i)
	{
		cout << base[i] << endl;
	}
}

// 入队
template<class Type>
bool SeqQueue<Type>::push(const Type &x)
{
	if (full())
	{
		cout << "the queue is full,can not enter!" << endl;
		return false;
	}
	else
	{
		base[tail] = x;
		tail++;
		return true;
	}
}

// 出队
template<class Type>
bool SeqQueue<Type>::pop()
{
	if (empty())
	{
		cout << "the queue is empty,can not pop!" << endl;
		return false;
	}
	else
	{
		head++;
		return true;
	}
}

// 获得队头元素
template<class Type>
void SeqQueue<Type>::gettop(Type &x)
{
	x = base[head];
}

// 求队列长度
template<class Type>
int SeqQueue<Type>::length()const
{
	return (tail - head);
}

// 清空队列
template<class Type>
void SeqQueue<Type>::clear()
{
	head = tail = 0;
}

// 摧毁队列
template<class Type>
void SeqQueue<Type>::destory()
{
	delete []base;
	base = NULL;
	capacity = head = tail = 0;
}

// 摧毁队列
template<class Type>
void SeqQueue<Type>::quit_system(Type &x)
{
	x = 0;
}

主函数:

#include "SeqQueue.h"

int main()
{
	SeqQueue<int> myqueue;
	int input = 1;
	int value;
	while (input)
	{
		cout << "****************************************************" << endl;
		cout << "*       [1] show                 [2] push          *" << endl;
		cout << "*       [3] pop                  [4] gettop        *" << endl;
		cout << "*       [5] length               [6] clear         *" << endl;
		cout << "*       [7] destory              [8] quit_syntem   *" << endl;
		cout << "****************************************************" << endl;
		cout << "please choose:";
		cin >> input;
		switch (input)
		{
		case 1:
			myqueue.show();
			break;
		case 2:
			cout << "please enter the number:";
			while (cin >> value, value != -1)
			{
				myqueue.push(value);
			}
			break;
		case 3:
			myqueue.pop();
			break;
		case 4:
			myqueue.gettop(value);
			cout << value << endl;
			break;
		case 5:
			cout << myqueue.length() << endl;
			break;
		case 6:
			myqueue.clear();
			break;
		case 7:
			myqueue.destory();
			break;
		case 8:
			myqueue.quit_system(input);
			break;
		default:
			break;
		}
	}
	return 0;
}

清空:

获得队头元素:

队列长度:

出队:

入队:

退出系统:

时间: 2024-12-14 12:16:02

【数据结构】顺序队列的实现(c++)的相关文章

数据结构 - 顺序队列的实行(C语言)

数据结构-顺序队列的实现 1 顺序队列的定义 线性表有顺序存储和链式存储,队列作为一种特殊的线性表,也同样存在这两种存储方式.我们先来看队列的顺序存储结构. 队列的顺序储存结构:用数组存储队列,为了避免当只有一个元素时,队头和队尾重合使得处理变得麻烦,所以引入两个指针:front指针指向队头元素,rear指针指向队尾元素的下一个位置,当front=rear时,为空队列,结构如下图所示. 假设是长度为5的数组,初始状态,空队列如下图左所示,front与 rear指针均指向下标为0的位置.然后入队a

数据结构——顺序队列(sequence queue)

/* sequenceQueue.c */ /* 顺序队列 */ #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define MAXSIZE 100 /* 顺序循环队列数据结构 */ /* 一个圆圈,front指向队列头,rear指向队列尾 */ /* front -> ... -> rear data[0] -> data[...] -> data[n] */ type

数据结构顺序队列打卡

程序能够运行出来,就是在给队列输入x值的时候不能够输进去,求解! #include<stdio.h>#define maxSize 8typedef int QElemType;typedef struct { QElemType elem[maxSize]; int front,rear;}CircQueue;//初始化void InitQueue (CircQueue &s){ s.front=s.rear=0;} //进队列 int EnQueue (CircQueue &

数据结构-顺序队列

1 #include <iostream> 2 #include <stdlib.h> 3 using namespace std; 4 5 #define maxSize 20 6 7 typedef struct 8 { 9 int data[maxSize]; 10 int front; 11 int rear; 12 }SqQueue; 13 14 void InitQueue(SqQueue &Q) 15 { 16 Q.front=Q.rear=0; 17 } 1

数据结构Java实现07----队列:顺序队列&amp;顺序循环队列、链式队列、顺序优先队列

数据结构Java实现07----队列:顺序队列&顺序循环队列.链式队列.顺序优先队列 一.队列的概念: 队列(简称作队,Queue)也是一种特殊的线性表,队列的数据元素以及数据元素间的逻辑关系和线性表完全相同,其差别是线性表允许在任意位置插入和删除,而队列只允许在其一端进行插入操作在其另一端进行删除操作. 队列中允许进行插入操作的一端称为队尾,允许进行删除操作的一端称为队头.队列的插入操作通常称作入队列,队列的删除操作通常称作出队列. 下图是一个依次向队列中插入数据元素a0,a1,...,an-

数据结构6_顺序队列(循环队列)

本文实现了顺序队列,与链队列不同的是,顺序队列需要考虑一个问题, 问题情况如下, 解决办法:循环队列,当rear到分配的数组空间末尾时,转到数组头 但是当q.rear==q.front时,又如何区分一种是空队列,一种是满队列的情况呢 这里有两种方案 本次代码实现了第一种方法,同时设置了一个技术变量length,稍加改动便可实现第二个方法 代码如下: #include<iostream>using namespace std;//该顺序队列为循环队列,解决队尾指针达到最大值,队列中有空闲单元,但

数据结构--队列实现(顺序队列和链队列)与C++模板

数据结构--队列实现(顺序队列和链队列)与C++模板 一.顺序队列 队列的顺序存储结构称为顺序队列,顺序队列实际上是运算受限的顺序表. ①和顺序表一样,顺序队列用一个向量空间来存放当前队列中的元素. ②由于队列的队头和队尾的位置是变化的,设置两个指针front和rear分别指示队头元素和队尾元素在向量空间中的位置,它们的初值在队列初始化时均应置为0. 注意: ①当头尾指针相等时,队列为空. ②在非空队列里,队头指针始终指向队头元素,尾指针始终指向队尾元素的下一位置.(所以以下循环顺序队列中当队尾

数据结构(C实现)------- 顺序队列(循环队列之少用一个存储空间实现) .

上节已经提到有三种方法来实现循环顺序队列,其中第一种设立标识不常用,最常的就是后两种,上一节已经讨论了用计数器来实现循环顺序队列,这节就用第三种方法,也就是少用一个存储空间来实现循环顺序队列,其基本操作和用计数实现类同,下面是具体实现: 顺序队列(循环队列)类型描述: //顺序队列的类型描述 #define MAXSIZE 5 typedef int ElemType; typedef struct{ ElemType *data; int front,rear; }SqQueue; 基本操作:

[数据结构]队列之顺序队列的类模板实现

队列是一种限定存取位置的线性表.同意插入的一端叫做队尾(rear),同意删除的一端叫做队首(front). 队列具有FIFO的性质 队列的存储表示也有两种方式:基于数组的,基于列表的.基于数组的叫做顺序队列.基于列表的叫做链式队列. 一下是基于动态数组的顺序队列的模板类的实现. 顺序队列的抽象基类例如以下所看到的:仅仅提供了接口和显式的默认构造函数和析构函数,在派生类中调用. #ifndef QUEUE #define QUEUE //队列的抽象基类 template<class T> cla