数据结构–队列

• 数据结构队列 队列是什么
• C艹实现的思路
• C代码实现队列链表版
• 一些注意事项

队列是什么？

队列-百度百科

• 嗯，先讲讲我的理解，队列就像我们生活中排队，先到先得，先进先出
  即FIFO-First In First Out（类似的还有栈，FIFO,first in last out)
  队列有前端(front)和后端(rear)，每次需要数据时从前端取出，每次增加数据时在队尾增加。

C艹实现的思路

1. 首先来看队列中单个结点的实现：

template<typename value>
struct Node {
Node(value d) :data(d), next(NULL) {}
value data;
Node* next;
};

其中，有数据部分，有指向下一个结点的指针

1. 再来看队列部分中有什么：

int _size;
Node<value>* front;
Node<value>* rear;

1. 希望实现的功能
   
   创建列表
   • 复制列表
   • 加入元素
   • 弹出元素
   • 一些运算符重载
   • 查看是否为空列表
   • 按从队首到队尾顺序输出元素

C++代码实现队列（链表版）

using std::cout;
using std::endl;
namespace my{

//the node in the queue
template<typename value>
struct Node {
Node(value d) :data(d), next(NULL) {}
value data;
Node* next;
};

template<typename value>
class queue {

private:
int _size;
Node<value>* front;
Node<value>* rear;
template<typename value>
friend void copy(queue<value> & dst, const queue<value> & src);

public:
//constructor function have the ability to init the queue
queue()
{
_size = 0;
front = NULL;
rear = NULL;
}
~queue() {  }

bool isEmpty();
bool push(value n);

value pop();

void destroy_queue();
void print();

//operator + overload
friend queue<value> operator+(value v, queue<value> q)
{
q.push(v);
return q;
}
friend queue<value> operator+(queue<value> q, value v)
{
q.push(v);
return q;
}
};

//whether the front element in queue is empty
template<typename value>
bool queue<value>::isEmpty()
{
return _size == 0;
}

//add element after queue's rear
template<typename value>
bool queue<value>::push(value n)
{

Node<value> *p = NULL;
p= new Node<value>(n);
if (p != NULL) {
if (this->front == NULL) {
this->front = p;
}
else {
this->rear->next = p;
}
rear = p;
_size++;
return true;
}
return false;
}

//get the first data in queue and delite it

template<typename value>
value queue<value>::pop()
{
if (front == NULL) {
return false;
}
else {
value n;
Node<value> *p;
p = this->front;
front = p->next;
n = p->data;
free(p);
_size--;
return n;
}
}

//destroy the queue
template<typename value>
void queue<value>::destroy_queue()
{
Node<value> *temp;
Node<value> *p = front;
while (p != NULL) {
temp = p;
p = p->next;
delete temp;

}
~queue();
}

//print the data in queue in order
template<typename value>
void queue<value>::print()
{
Node<value> *p;
p = this->front;
while (p != NULL) {
cout << p->data;
p = p->next;
}

cout << endl;

}

//copy the queue to another new established queue
template<typename value>
void copy(queue<value> & dst, const queue<value> & src)
{
if (src.front == NULL) {
return;
}
Node<value> *p = src.front;
value v;
while (p != NULL) {
v = p->data;
p = p->next;
dst.push(v);
}
}

}

int main()
{
my::queue<int> q;
my::queue<int> d;
if (q.isEmpty() == true) {
cout << "The queue has been empty ! " << endl;
}
else
cout << "the queue is not empty" << endl;
for (int i = 0; i < 10; i++) {
q = i + q;
}
q.print();

for (int i = 0; i < 3; i++) {
q.pop();
}

q.print();

my::copy(d, q);
d.print();

std::cin.get();
return 0;
}

一些注意事项

• 在实现复制功能时，用到了友元函数，其中特别注意友元函数虽然在类中声明，但它实际上算是‘外面’的函数，只不过对这个类有很高的‘权限’罢了，所以在类中声明时前面也要加template

  欢迎留言哦！