• 栈的定义--Stack

栈只允许在末端(即是栈顶)进行插入和删除的线性表。栈具有后进先出的特性(LIFO,Last In First Out)。

wKiom1c2ze-wfC2pAAA7RVXBfQk320.png

下面是关于栈的实现:

#include<iostream>

#include<string>

using namespace std;


template<class T>

//栈有动态与静态之分

//栈适合用顺序表(无中间插入与删除时最好用数组),因为栈选顺序表(即是数组),进行size++与size--比较方便,而且效率较高。并且它的CPU高速缓存利用(即命中)率更高,命中,即是缓存中有,用时可以直接从缓存中取数据。

class stack

{

protected:

           T* _a;     //T类型的指针,指向顺序表(数组)

           size_t _size;    //数据的个数

           size_t _capacity;    //栈的容量


public:


          stack( const stack <T> & s)//拷贝构造函数

                   :_a( new T [_size])   //此处的_size也可以换成_capacity,但是最好不要,因为这样会浪费空间。

                   ,_size(s._size)

                   , _capacity(s._size)

          {

                              for (size_t i = 0; i < _size; ++i)

                             {

                                      _a[i] = s.q[i];

                             }


          }


           //stack<T> &operator=(const stack<T> &s)   //赋值运算符重载

           //{

           //赋值运算符重载的传统写法

           //       if (this != &s)   //首先判断是不是自己给自己赋值

           //       {

           //                 //此处记住不能先释放空间,即delete[] _a,因为先释放再分配空间有缺陷,因为开辟空间可能会失败,但是释放空间一定会成功。

           //                 T* tmp = new T[s._size];

           //                 for (size_t i = 0; i < _size; ++i)

           //                 {

           //                          tmp[i] = s._a[i];

           //                 }

           //                 delete[] _a;

           //                 _a = tmp;

           //       }

           //       return *this;

           //}


           stack<T > &operator=(const stack<T > &s)

          {

           //赋值运算符重载的现代写法(更好)

                   swap(_a, s._a);

                   swap(_size, s._size);

                   swap(_capacity, s._capacity);

                    return *this ;

          }


           void Push(const T& x)

          {

           //检查容量

                   _CheckCpapacity();

                   _a[_size++] = x;

          }

           void Pop()

          {

                   assert(_size > 0);

                   --_size;

          }

           T& Top()   //返回栈顶元素

          {

                   assert(_size > 0);

                    return _a[_size - 1];

          }

           bool Empty()

          {

                    return _size == 0;

          }

           size_t  size()

          {

           return

          }

protected:

           void _CheckCapacity()

          {

                    if (_size == _capacity)

                   {

                             _capacity = _capacity * 2 + 3;

                              T* tmp = new T[_capacity];

                              if (_a)

                             {

                                       for (size_t i = 0; i < _size; ++i)

                                      {

                                                tmp[i] = _a[i];


                                      }

                                       delete[] _a;

                             }

                             _a = tmp;

                   }

          }


};

队列的定义

队列值允许在表的队尾进行插入,在表对头进行删除。队列具有先进先出的特性。(FIFO,first In First Out)

下面是队列的实现

//队列全是动态,没有静态。最好用链式结构。

template<typename T>

struct Node

{

T _data;

Node<T > * _next;

};


template<class T>


class queue

{

protected:

           Node<T > * _tail;

           Node<T > * _head;


public:

          queue()

                   :_head( NULL)

                   , _tail( NULL)

          {}


          queue( const queue <T> & q)    //拷贝构造函数

                   :_head( NULL)

                   , _tail( NULL)

          {

                    Node<T > *cur = q._head;

                    while (cur)

                   {

                             Push(cur->_data);

                             cur = cur->_next;

                   }

          }


           //queue<T> &operator=(const queue &q)    //赋值运算符重载

           //{

           //       //传统写法

           //       if (this != &q)

           //       {

           //                 clear();

           //                 Node<T> *cur = q._head;

           //                 while (cur)

           //                 {

           //                          Push(cur->_data);

           //                          cur = cur->_next;

           //                 }

           //       }

           //       return *this;

           //}


           queue<T > &operator=(const queue &q )    //赋值运算符重载

          {

           //现代写法

                   swap(_head, q._head);

                   swap(_tail, q._tail);

                    return *this ;

          }

         

          ~queue()

          {

                    Node<T > *cur = _head;

                    while (cur)

                   {

                              Node<T > *del = cur;

                             cur = cur->_next;

                              delete del;

                   

                   }

                   _head = NULL;

                   _tail = NULL;

          }

           void Push(const T& x)

          {

                    if (_head == NULL )

                   {

                             _head = _tail = new Node <T>( x);

                   }

                    else

                   {

                             _tail->_next = new Node <T>( x);

                             _tail = _tail->_next;

                   }

          }

           void Pop()               //出队操作,,有三种情况,分别为队列为空,队列只有一个结点,队列有多个结点。

          {

                   assert(_head);

                    if (_head == _tail)   //头指针等于尾指针,即只有一个结点。

                   {

                              delete _head;

                             _head = _tail = NULL;

                   }

                    else

                   {

                              Node<T > *del = _head;

                             _head = _head->_next;

                              delete del;

                   }

          }

           T& Front()       //返回队列的第一个元素

          {

                    return _head->_data;

          }

           T& Back()      //返回队列的最后一个元素

          {

                    return _tail->_data;

          }

           bool Empty()    //判断队列是否为空

          {

                    return _head == NULL ;

          }

           size_t size()     //返回队列的结点的个数

          {

                    size_t size = 0;

                    Node<T > *cur = _head;

                    while (cur)

                   {

                             ++size;

                             cur = cur->_next;

                   }

                    return size;

          }

};