模板（顺序表与栈）

”顺序表与栈“

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

这里首先提一下“模板”的概念，模板的一般形式为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;
};