数据结构：队列C++实现（入门）

数据结构：队列

队列（queue）是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。

队列是一种先进先出（First In First Out）的线性表，简称FIFO。允许插入的一端称为队尾，允许删除的一端称为 队头。假设队列是q=(a1,a2,…,an)，那么a1就是队头元素，而an是队尾元素。这样我们就可以删除时，总是从a1开始，而插入时，列在最后。这也比较符合我们通常生活中的习惯，排在第一个的优先出列，最后来的当然排在队伍最后 出列。

1.头文件my_Queue

//实现一个队列的头文件

#ifndef Queue_h_
#define Queue_h_

class Queue
{
public:
	Queue(int  QueueCapaticy);                      //构造函数
	~Queue();                                                           //析构函数
	void clearQueue();                                        //清除对列里的数据
	bool emptyQueue() const;                    //判断队列是否为空
	bool fullQueue();                          //判断是否满列
	int QueueLen();                           //返回长度
	void enterQueue(int element);                      //数据进入
	void deleteQueue(int element);                      //数据出列
	void travelQueue();                                        //遍历列

private:
	int m_QueueCapaticy;                       //队列的容量
	int m_QueueLen;                                  //队列的长度
	int m_Head;                                             //队列头
	int m_Tail;                                                //队类尾
	int* m_pQueue;                                   //队列指针
};
#endif

2.成员函数实现

#include<iostream>
#include "my_queue.h"
using namespace std;

//构造 函数
Queue::Queue(int QueueCapaticy)                           
{
	m_QueueCapaticy = QueueCapaticy;
	m_pQueue = new int[m_QueueCapaticy];                 //在堆上分配空间
	m_Head = 0;
	m_Tail = 0;
	m_QueueLen = 0;
}

//析构函数
Queue :: ~Queue()                                
{
	delete[] m_pQueue;
	m_pQueue = NULL;
}

//清空队列
void Queue::clearQueue()
{
	m_QueueLen = 0;
	m_Head = 0;
	m_Tail = 0;
}

//判断是否为空
bool Queue::emptyQueue() const 
{
	return m_QueueLen == 0 ? true : false;
}

//判断是否满列
bool Queue :: fullQueue()
{
	return m_QueueLen == m_QueueCapaticy ? true : false;
}

//返回队列长度
int Queue::QueueLen()
{
	return m_QueueLen;
}

//数据入队
void Queue :: enterQueue(int element)
{
	if (fullQueue() == false)
	{
		m_pQueue[m_Tail] = element;
		m_Tail++;
		m_Tail = m_Tail % m_QueueCapaticy;             //防止溢出
		m_QueueLen++;
	}
}

//数据出队
void  Queue :: deleteQueue(int element)
{
	if (emptyQueue() == false)
	{
		m_pQueue[m_Head] = element;
		m_Head++;
		m_Head = m_Head % m_QueueCapaticy;         //防止溢出
		m_QueueLen--;
	}
}

//遍历队列
void Queue::travelQueue()
{
	for (int i = m_Head; i < m_Head + m_QueueCapaticy; i++)            //确保全部遍历
	{
		cout << m_pQueue[i % m_QueueCapaticy] << endl;
	}
}

3.测试

#include <iostream>
#include "my_Queue.h"
using namespace std;

int main()
{
	Queue* p = new Queue(4);
	p->enterQueue(1);
	p->enterQueue(2);
	p->enterQueue(3);
	p->enterQueue(4);

	p->deleteQueue(5);
	//p->deleteQueue(6);
	cout << p->QueueLen() << endl;

	p->enterQueue(6);


	p->travelQueue();

	delete p;
	p = NULL;
	system("pause");
	return 0;
}

4.申明：

这仅仅是一个初级的例子，实现的方式效率很低并且其中存在一些弊