不使用库实现队列的基本操作

template < typename T >

struct Node

{ public :

                Node( const T & d )

                                :_data(0)

                                , _next( NULL )

                                , _pre( NULL )

                {  }

                 T * _data;

                 Node < T >* _next;

                 Node < T >* _pre;

};

template < typename T >

class Queue   //先进先出，

{

public :

                Queue()

                                :_tail( NULL )

                                , _head( NULL )

                                , _size(0)

                {  }

                 void Push( const T & n )

                {

                                 if (_size == 0)

                                {

                                                _head = _tail = _ByeNode( n );

                                }

                                 else

                                {

                                                 Node < T > *temp = _ByeNode( n );

                                                _tail->_next = temp;

                                                temp->_pre = _tail;

                                                _tail = _tail->_next;

                                }

                                _size++;

                }

                 void Pop()   //移除一个元素,删除队头

                {

                                 if (_size == 0)

                                {

                                                 return ;

                                }

                                 else if (_size = 1)

                                {

                                                 delete _head;

                                                _head = NULL ;

                                                _tail = NULL ;

                                }

                                 else

                                {

                                                _head =_head->_next;

                                                 delete _head->_pre;

                                }

                                _size--;

                }

                 T & Front()   //返回第一个插入的元素,即队头

                {

                                 return _head;

                }

                 T & Back()   //返回最后被插入的元素，即队尾

                {

                                 return _tail;

                }

                 bool Empty()  //队列为空时，返回true

                {

                                 if (_size == 0)

                                {

                                                 return true ;

                                }

                                 else

                                {

                                                 return false ;

                                }

                }

                 size_t Size()  //队列中元素个数

                {

                                 return _size;

                }

                 Node < T > * _ByeNode( const T & n )

                {

                                 return new Node < T >( n );

                }

protected :

                 Node < T >* _tail;

                 Node < T >* _head;

                 size_t _size;

};