数据结构——线性表：顺序队列、链式队列（C++）

内容概要：

• 队列的相关概念
• 注意事项
• code:队列抽象类、顺序队列类、链式队列类

---

一、队列的相关概念

• 队列是一种受限制的线性表，其特点是“先进先出”（FIFO）。
• 队列元素只能从队尾插入（入队操作：enqueue）、从队首删除（出队操作：dequeue）。
• 顺序队列用数组/顺序表实现，队列元素个数受限，为提高效率，循环使用数组/顺序表。

      

      

• 链式队列用链表存储，队列元素个数不限。

二、注意事项：

• 顺序队列判断队列为空还是为满的两种方法：①使用一个成员变量记录队列中的元素的个数。②设置数组/顺序表大小为n+1，但只存储n个元素。
• 链式队列使用头节点简化操作。

三、Code(测试环境VS2017)

//ADT_queue.h
#ifndef ADT_QUEUE_H
#define ADT_QUEUE_H

template<typename E>
class Queue
{
private:
	void operator =(const Queue&){}
	Queue(const Queue&) {}

public:
	Queue(){}
	virtual ~Queue(){}

	virtual void clear() = 0;
	virtual void enqueue(const E&it) = 0;
	virtual E dequeue() = 0;
	virtual const E& frontValue() const = 0;
	virtual int length() const = 0;
};

#endif // !ADT_QUEUE_H

//array_based_queue.h
#ifndef ARRAY_BASED_QUEUE_H
#define ARRAY_BASED_QUEUE_H

#include<cassert>
#include"ADT_queue.h"

template<typename E>
class AQueue :public Queue<E>
{
private:
	int maxSize;
	int front;
	int rear;
	E*listArry;

public:
	AQueue(int size = 100)//default size 100,if front-rear=-1-->queue full
	{
		front = 1;
		rear = 0;
		maxSize = size + 1;
		listArry = new E[maxSize];
	}
	~AQueue() { delete listArry; }

	void clear() { rear = 0; front = 1; }
	void enqueue(const E&it)
	{
		assert((rear + 2) % maxSize != front);//queue is full
		rear = (rear + 1) % maxSize;
		listArry[rear] = it;
	}
	E dequeue()
	{
		assert(length() != 0);//queue is empty
		E it = listArry[front];
		front = (front + 1) % maxSize;
		return it;
	}
	const E& frontValue() const
	{
		assert(length() != 0);//queue is empty
		return listArry[front];
	}
	int length()const{ return((rear + maxSize - front + 1) % maxSize); }
};

#endif // !ARRAY_BASED_QUEUE_H

//linked_queue.h
#ifndef LINKED_QUEUE_H
#define LINKED_QUEUE_H

#include<assert.h>
#include"ADT_queue.h"

template<typename E>
class Link
{
public:
	E element;
	Link<E>*next;

	Link(const E& ele, Link*nex = NULL) { element = ele; next = nex; }
	Link(Link*nex = NULL) { next = nex; };
};

template<typename E>
class LQueue:public Queue<E>
{
private:
	Link<E> * front;
	Link<E> * rear;
	int size;

public:
	LQueue() { front = rear = new Link<E>(); size = 0; }
	~LQueue() 
	{ 
		clear();
		delete front; 
	}

	void clear()
	{
		while (front->next != NULL)
		{
			rear = front;
			delete rear;
		}
		rear = front;
		size = 0;
	}
	void enqueue(const E&it)
	{
		rear->next = new Link<E>(it);
		rear = rear->next;
		size++;
	}
	E dequeue()
	{
		assert(size != 0);//queue is empty
		E it = front->next->element;
		Link<E>*temp = front->next;
		front->next = temp->next;
		if (rear == temp)
			rear = front;
		delete temp;
		size--;
		return it;
	}
	const E& frontValue()const { assert(size!=0); return (front->next->element); }
	int length() const { return size; }
};

#endif // !LINKED_QUEUE_H

数据结构与算法分析（第三版）》P82-P86

//main.app
#include"array_based_queue.h"
#include"linked_queue.h"
#include<iostream>
using namespace std;

int main()
{
	//test place

	AQueue<int> a(10);
	for (int i = 0; i < 10; i++)
		a.enqueue(i);
	for (int i = 0; i < 10; i++)
		cout<<a.dequeue()<<"	 ";
	cout << endl;

	LQueue<char> s;
	for (int i = 0; i < 10; i++)
		a.enqueue((char)(i+'a'));
	for (int i = 0; i < 10; i++)
		cout << (char)a.dequeue() << "	 ";
	cout << endl;

	system("pause");
}