顺序表和链表的模板

//模板的顺序表

template<class T>
class SeqList
{
public:
SeqList()
:_array(NULL)
, _size(0)
, _capacity(0)
{}

~SeqList()
{
if (_array)
{
delete[] _array;
//free(_array);
}
}

SeqList(const SeqList<T>& s)
{
_array = new T[_capacity];
//_array = (T*)malloc(sizeof(T)*s._capacity);
/*memcpy(_array, s._array, s._capacity);*/   //只是将数组的首元素 赋值过去，并没有将所有值赋值过去。
for (int i = 0; i < s._size; i++)
{
_array[i] = s._array[i];
}
_size = s._size;
_capacity = s._capacity;
}

SeqList<T>& operator=(const SeqList<T>& s)
{
if (this != &s)
{
_array = new T[_capacity];
/*memcpy(_array, s._array, s._capacity);*/   //只是将数组的首元素 赋值过去，并没有将所有值赋值过去。
for (int i = 0; i < s._size; i++)
{
_array[i] = s._array[i];
}
_size = s._size;
_capacity = s._capacity;
}
return *this;
}

void PushBack(const T& x)
{
_CheckCapacity();
_array[_size++] = x;
}

void PopBack()
{
if (_size > 0)
{
_size--;
}
else
{
cout << "NO DATA!" << endl;
}
}

void Print()
{
for (int i = 0; i < _size; i++)
{
cout << _array[i] << "->";
}
cout << endl;
}

protected:
void _CheckCapacity()
{
if (_size >= _capacity)
{
/*_capacity = _capacity * 2 + 1;
_array = (T*)realloc(_array, sizeof(T)*_capacity);*/

_capacity = _capacity * 2 + 1;
T* tmp = new T[_capacity];                //考虑到string类型，用malloc\realloc不会调用构造函数
if (_array)
{
memcpy(tmp, _array, _size);
}
delete[] _array;

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

void Test1()
{
SeqList<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);

SeqList<int> s2(s1);

s2.PushBack(5);
s2.PushBack(6);
s2.PushBack(7);
s2.PushBack(8);
s2.PushBack(9);

s1.Print();
s2.Print();
}

void Test2()
{
SeqList<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);

s1.Print();

s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();

}

void Test3()
{
SeqList<int> s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);

SeqList<int> s2;
s2 = s1;

s1.Print();
s2.Print();
}

template<class T>     //模板定义友元的时候是需要在声明的
class LinkList;

template<class T>
class LinkListNode
{
friend class LinkList<T>;
public:
LinkListNode(const T& x)
:_data(x)
, _next(NULL)
{}
private:
T _data;
LinkListNode<T>* _next;
};

template<class T>
class LinkList
{
public:
LinkList()
:_head(NULL)
{}

~LinkList()
{
if (_head)
{
delete _head;
}
}

LinkList(const LinkList<T>& l)        //一个一个结点赋值
{
LinkListNode<T>* cur = l._head;
while (cur)
{
if (_head == NULL)
{
_head = new LinkListNode<T>(cur->_data);
}
else
{
LinkListNode<T>* tmp = new LinkListNode<T>(cur->_data);
LinkListNode<T>* cur = _head;
while (cur->_next)
{
cur = cur->_next;
}
cur->_next = tmp;
tmp->_next = NULL;
}
cur = cur->_next;
}
}

void PushBack(const T& x)
{
if (_head == NULL)
{
_head = new LinkListNode<T>(x);
}
else
{
LinkListNode<T>* tmp = new LinkListNode<T>(x);
LinkListNode<T>* cur = _head;
while (cur->_next)
{
cur = cur->_next;
}
cur->_next = tmp;
tmp = NULL;
}
}

void print()
{
LinkListNode<T>* cur = _head;
while (cur)
{
cout << cur->_data << "->";
cur = cur->_next;
}
}

private:
LinkListNode<T>* _head;
};

void Test3()
{
LinkList<int> l1;

l1.PushBack(1);
l1.PushBack(2);
l1.PushBack(3);
l1.PushBack(4);

l1.print();

}

void Test4()
{
LinkList<int> l1;

l1.PushBack(1);
l1.PushBack(2);
l1.PushBack(3);
l1.PushBack(4);

LinkList<int> l2(l1);
l1.print();

cout << endl;
l2.print();
}