模板（顺序表与栈）

”顺序表与栈“

顺序表相对于我们来说已经不算是陌生的，顺序表有自己独有的特点，需要有一块独有的空间，访问中间的数据也较为简单，插入和删除数据就相对较难。针对顺序表的特点，我们不难想到一个数据结构“栈”，栈的特点与顺序表相对来说很接近，栈的主要特点是”先进后出“，即就是后进入栈的数据必须先出才能够访问到先前进入的数据，用顺序表来实现“栈”的一些基本功能更加合适。

这里首先提一下“模板”的概念，模板的一般形式为template<class 形参名1， class 形参名2> ；模板的实例化为：

template <typename T>      //这里也可以用class
bool IsEqual(const T& left, const T& right)
{
         return left == right;
}

void test1()
{
        cout << IsEqual<int>(1, 1.2) << endl;
}

下面主要是利用模板来实现顺序表，这样的好处在于可以针对各种的数据类型，避免了直接将顺序表中的数据类型进行限制，局限性降低。同时利用顺序表的功能来实现栈，下面是用模板来实现顺序表：

#pragma once
//顺序表
template <class T>
class SeqList
{
public:
    SeqList()     //无参构造函数
       :_array(NULL)
       , _size(0)
       , _capacity(0)
    { }
    
    SeqList(const SeqList<T>& x)    //拷贝构造函数
       :_array(new T[x._size])
       , _size(x._size)
       , _capacity(x._size)
    {
        //memcpy(_array, x._array, sizeof(T)*(x._size));
        if (_array)
        {
            for (int i = 0; i < x._size; i++)
            {
                _array[i] = x._array[i];
            }
        }
    }
    
    ~SeqList()     //析构函数
    {
        if (_array)
        {
            delete[] _array;
         }
    }
    
    SeqList<T>& operator=(SeqList<T>& x)      //赋值运算符重载
    {
        if (this != &x)
       {
           SeqList * tmp = new T[x._size];
           delete[] _array;
           _array = tmp;
           _size = x._size;
           _capacity = x._size;
           memcpy(_array, x._array, sizeof(T)*(x._size));
       }
       return *this;
    }
    
    SeqList<T> & operator[](size_t index)
    {
        assert(index < _size);
        return _array[index];
    }
    
public:
    void pushBack(const T& x)    //尾插
    {
        _checkCapacity(_size + 1);
        _array[_size++] = x;
    }
    
     void popBack()     //尾删
     {
         if (_size <= 0)
         {
             return;
         }
         else
        {
             _array[_size - 1] = NULL;
             _size--;
         }
     }
     
     void pushFront(const T& x)     //头插
     {
         _checkCapacity(_size + 1);
         for (int i = 0; i < _size; i++)
         {
             _array[_size - i] = _array[_size - 1 - i];
         }
         _array[0] = x;
         _size++;
     }
     
     void popFront()    //头删
     {
         if (_size)
         {
             for (int i = 0; i < _size; i++)
             {
                 _array[i] = _array[i + 1];
              }
          }
          _size--;
     }
     
     void Insert(size_t pos, const T &x)   //任何位置插入
    {
        if (pos < 0 || pos > _size)
        {
            return;
        }
         else
        {
            for (int i = _size; i > pos; i--)
            {
                _array[i] = _array[i - 1];
            }
             _array[pos] = x;
             _size++;
        }
    }
    
     void Erase(size_t pos)    //删除pos位置的数据
    {
        if (pos < 0 || pos > _size)
        {
            return 0;
        }
        else
        {
            for (int i = pos; i < _size; i++)
            {
                _array[i - 1] = _array[i];
             }
             _size--;
        }
    }
    
     int Find(T & x)    //查找
    {
        for (int i = 0; i < _size; i++)
        {
            if (x == _array[i])
            {
                return i + 1;
             }
         }
        if (i >= _size)
        {
             return 0;
        }
    }
    
     void print()   //格式输出
    {
        for (int i = 0; i < _size; i++)
       {
            cout << _array[i] << " ";
       }
        cout << endl;
    }

     void _checkCapacity(size_t n)    //检查容量
    {
        if (n > _capacity)
        {
             _capacity = n > 2 * _capacity + 3 ? n : (2 * _capacity + 3);
            //不能直接用realloc来增容，realloc不会调用构造函数，
            //不能对其空间进行初始化，而new可以直接调用构造函数
            T * tmp = new T[_capacity];
            if (_array)
           {
               for (int i = 0; i < _size; i++)
               {
                   tmp[i] = _array[i];
                }
               delete[] _array;
           }
           _array = tmp;
        }
    }

     size_t Size()
     {
         return _size;
     }
     
     T& Top()
     {
         return _array[_size-1];
      }

private:
     T* _array;
     int _size;
     int _capacity;
};

下面是“栈”的基本功能实现：

#pragma once
#include <assert.h>
#include "SeqList.h"
//栈
template <class T, class container = SeqList<T>>
class Stack
{
public:
     void push(const T & x)     //压栈
     {
         _con.pushBack(x);
     }
     
      void pop()      //出栈
     {
         _con.popBack();
     }
     
      bool Empty()      //判空
     {
         return _con.Size() == 0;
     }
     
     size_t size()    //计算元素个数
    {
         return _con.Size();
     }
     
     T & top()        //读取栈顶元素
    {
        return _con.Top();
     }
private:
    container _con;
};