数据结构--队列

数据结构–队列

队列是什么？

队列-百度百科

• 嗯，先讲讲我的理解，队列就像我们生活中排队，先到先得，先进先出
  即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

                        欢迎留言哦！