数据结构探险（一）队列篇

一、什么是数据结构

数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。

二、队列原理

1.什么是队列？先入先出（FIFO—— First In First Out）数学模型

2.分类：普通队列、环形队列

3.用途？自动排号机...

三、面向对象的队列设计

//在MyQueue.h文件中

#ifndef MYQUEUE_H
#define MYQUEUE_H

/******************************************/
/*环形队列C++实现   2018-7-24   by Excalibur*/
/******************************************/

class MyQueue
{
public:
	MyQueue(int queueCapacity);		//创建队列
	virtual ~MyQueue();				//销毁队列
	void ClearQueue();				//清空队列
	bool QueueEmpty() const;		//判队空
	bool QueueFull() const;			//判队满
	int QueueLength() const;		//队列长度
	bool EnQueue(int element);		//元素入队
	bool DeQueue(int &element);		//元素出队
	void QueueTraverse();			//遍历队列

private:
	int *m_pQueue;			//队列数组指针
	int m_iQueueLen;		//队列元素个数
	int m_iQueueCapacity;	//队列数组容量
	int m_iHead;
	int m_iTail;
};

#endif // !MYQUEUE_H

//在MyQueue.cpp文件中

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

MyQueue::MyQueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
	m_pQueue = new int[m_iQueueCapacity];
}
MyQueue::~MyQueue()
{
	delete[] m_pQueue;
	m_pQueue = NULL;
}
void MyQueue::ClearQueue()
{
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
}
bool MyQueue::QueueEmpty() const
{
	/*if (m_iQueueLen == 0)
		return true;
	else
		return false;*/

	//Ctrl+k  Ctrl+c -> 快速注释；   Ctrl+k  Ctrl+u -> 快速注释；
	return m_iQueueLen == 0 ? true : false;
}
bool  MyQueue::QueueFull() const
{
	return m_iQueueCapacity == m_iQueueLen ? true : false;
}
int MyQueue::QueueLength() const
{
	return m_iQueueLen;
}
bool MyQueue::EnQueue(int element)		//元素入队
{
	if (QueueFull())
	{
		return false;
	}
	else
	{
		m_pQueue[m_iTail] = element;
		m_iTail++;
		m_iTail %= m_iQueueCapacity;
		m_iQueueLen++;
		return true;
	}
}
bool MyQueue::DeQueue(int &element)		//元素出队
{
	if (QueueEmpty())
	{
		return false;
	}
	else
	{
		element = m_pQueue[m_iHead];
		m_iHead++;
		m_iHead %= m_iQueueCapacity;
		m_iQueueLen--;
		return true;
	}
}
void MyQueue::QueueTraverse()			//遍历队列
{
	for (int i = m_iHead; i < m_iQueueLen+m_iHead; i++)
	{
		cout << m_pQueue[i%m_iQueueCapacity] << endl;
	}
}

//在demo.cpp文件中

#include <iostream>
#include <stdlib.h>
#include "MyQueue.h"

using namespace std;

int main()
{
	MyQueue *queue = new MyQueue(4);

	queue->EnQueue(10);
	queue->EnQueue(5);
	queue->QueueTraverse();
	int e = 0;
	queue->DeQueue(e);
	queue->QueueTraverse();
	queue->EnQueue(8);
	queue->QueueTraverse();

	queue->ClearQueue();
	queue->EnQueue(10);
	queue->QueueTraverse();

	delete queue;
	queue = NULL;

	return 0;
}

四、队列的实际应用（用类模板实现通用数据类型的队列操作）

【问题1】

【解决】不要把模板类的申明和实现分开——不要把模板类分开成头文件和cpp。将main.cpp中的#include "1.h"换成#include "1.cpp"。定义类模板的时候不能分文件定义。 一定要牢记。

【问题2】

【解决】c++ 类中，当需要定义自己构造器，需要注意：

新的构造器中参数的赋值初始化需要在定义及.cpp中完成，不要在头文件中进行初始化。比如：

1>正确的：

Item_base.h文件中          Item_base(const string &book,double sales_price);

Item_base.cpp中          Item_base::Item_base(const string &book="",double sales_price=0.0 ):isbn(book),price(sales_price){} 

2>错误的：         

Item_base.h文件中     Item_base(const string &book="",double sales_price=0.0 );

此时将会出现错误为：

error C2572: “....”: 重定义默认参数

【问题3】

【解决】重载 << 运算符

【最终实现】

//在servant.h中

#ifndef SERVANT_H
#define SERVANT_H

/**********************************************/
/*Servant测试类的实现   2018-7-24   by Excalibur*/
/**********************************************/
#include <string>
#include <iostream>
using namespace std;

class TEST
{
public:
	TEST(int id1 = 0, string name1 = "", int age1 = 0);
	~TEST() { cout << "~test()"; }
	/*ostream& operator<<(ostream &a)
	{
		cout << a.age << endl;
		cout << a.id << endl;
		cout << a.name << endl;
	}*/
	friend ostream &operator<<(ostream &output,const TEST &D)
	{
		output << "id = " << D.id << endl;
		output << "name = " << D.name << endl;
		output << "age = " << D.age << endl;
		return output;
	}
private:
	int id;
	string name;
	int age;
};

TEST::TEST(int id1, string name1, int age1)
{
	id = id1;
	name = name1;
	age = age1;
}

#endif // !SERVANT_H

//在damo.cpp中
#include <iostream>
#include <stdlib.h>
#include "MyQueue.cpp"
#include <string>
#include "servant.h"
using namespace std;

int main()
{
	TEST c1(1,"saber",16);
	TEST c2(2, "archer", 20);
	TEST c3(3, "lancer", 22);

	MyQueue<TEST> *queue = new MyQueue<TEST>(4);
	queue->EnQueue(c1);
	queue->EnQueue(c2);
	queue->QueueTraverse();

	delete [] queue;
	queue = NULL;


	return 0;
}

//在MyQueue.cpp中

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

template <typename T>
class MyQueue
{
public:
	MyQueue(int queueCapacity);		//创建队列
	virtual ~MyQueue();				//销毁队列
	void ClearQueue();				//清空队列
	bool QueueEmpty() const;		//判队空
	bool QueueFull() const;			//判队满
	int QueueLength() const;		//队列长度
	bool EnQueue(T element);		//元素入队
	bool DeQueue(T &element);		//元素出队
	void QueueTraverse();			//遍历队列

private:
	T * m_pQueue;			//队列数组指针
	int m_iQueueLen;		//队列元素个数
	int m_iQueueCapacity;		//队列数组容量
	int m_iHead;
	int m_iTail;
};

template <typename T>
MyQueue<T>::MyQueue(int queueCapacity)
{
	m_iQueueCapacity = queueCapacity;
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
	m_pQueue = new T[m_iQueueCapacity];
}

template <typename T>
MyQueue<T>::~MyQueue()
{
	delete[] m_pQueue;
	m_pQueue = NULL;
}

template <typename T>
void MyQueue<T>::ClearQueue()
{
	m_iHead = 0;
	m_iTail = 0;
	m_iQueueLen = 0;
}

template <typename T>
bool MyQueue<T>::QueueEmpty() const
{
	/*if (m_iQueueLen == 0)
		return true;
	else
		return false;*/

	//Ctrl+k  Ctrl+c -> 快速注释；   Ctrl+k  Ctrl+u -> 快速注释；
	return m_iQueueLen == 0 ? true : false;
}

template <typename T>
bool  MyQueue<T>::QueueFull() const
{
	return m_iQueueCapacity == m_iQueueLen ? true : false;
}

template <typename T>
int MyQueue<T>::QueueLength() const
{
	return m_iQueueLen;
}

template <typename T>
bool MyQueue<T>::EnQueue(T element)		//元素入队
{
	if (QueueFull())
	{
		return false;
	}
	else
	{
		m_pQueue[m_iTail] = element;
		m_iTail++;
		m_iTail %= m_iQueueCapacity;
		m_iQueueLen++;
		return true;
	}
}

template <typename T>
bool MyQueue<T>::DeQueue(T &element)		//元素出队
{
	if (QueueEmpty())
	{
		return false;
	}
	else
	{
		element = m_pQueue[m_iHead];
		m_iHead++;
		m_iHead %= m_iQueueCapacity;
		m_iQueueLen--;
		return true;
	}
}

template <typename T>
void MyQueue<T>::QueueTraverse()			//遍历队列
{
	for (int i = m_iHead; i < m_iQueueLen+m_iHead; i++)
	{
		cout << m_pQueue[i%m_iQueueCapacity] << endl;
	}
}