C++模板及用模板实现双向循环链表，顺序表

模板是泛型编程的基础。

所谓泛型编程就是编写与类型⽆关的逻辑代码，是⼀种复⽤的⽅式。

模板分为模板函数和模板类。

函数模板格式:
template <class 形参名1, class 形参名2, class 形参名n>
返回类型 函数名(参数列表)
{
...
}
模板形参的定义既可以使⽤class，也可以使⽤typename，含义是相同的。

注:模板未实例化时，代码内部的语法错误检测不到。

双向循环链表

链表分为有头结点和无头结点，单向和双向，循环和不循环

这里实现一个有头结点的双向循环链表

#include<iostream>
#include<windows.h>
#include<assert.h>
using namespace std;
template<class T>
struct ListNode
{
T _data;
ListNode<T>* _next;
ListNode<T>* _prev;

ListNode(const T& x=T())
:_data(x)
, _next(NULL)
, _prev(NULL)
{}
};
template<class T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node;
_head->_prev = _head;
_head->_next = _head;
}

//传统写法
List(const List<T> &l)
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;

Node*cur = l._head->_next;
while (cur != l._head)
{
PushBack(cur->_data);
cur = cur->_next;
}
}

//现代写法
List<T>&operator=(List<T> l)
{
swap(_head, l._head);

return *this;

}

~List()
{
Clear();
delete _head;

}
void Clear()//不清除头结点
{
Node*cur = _head->_next;
while (cur != _head)
{
Node*del = cur;
cur = cur->_next;
delete del;
}
_head->_next = _head;
_head->_prev = _head;
}

//增删查改
void PushBack(const T&x)
{
//Node*tail = _head->_prev;//找到尾结点
//Node*tmp = new Node(x);//创建新节点

//_head->_prev = tmp;
//tmp->_next = _head;

//tail->_next = tmp;
//tmp->_prev = tail;
Insert(_head, x);
}
void PopBack()
{
//assert(_head->_next != _head);//断言
//Node*tail = _head->_prev;//找到尾结点
//Node*prev = tail->_prev;//找到尾结点的前一个结点
//delete tail;//删除尾结点

//_head->_prev = prev;//头结点的前一个结点为prev
//prev->_next = _head;//prev的后一个结点为_head
Erase(_head->_prev);
}
void PopFront()
{
//assert(_head->_next != _head);
//Node*tmp = _head->_next;
//Node*next = tmp->_next;
//delete tmp;
//
//_head->_next = next;
//next->_prev = _head;

Erase(_head->_next);

}
void PushFront(const T&x)
{
//Node*tmp = new Node(x);
//Node*next = _head->_next;

//_head->_next = tmp;
//tmp->_prev = _head;

//tmp->_next = next;
//next->_prev = tmp;
Insert(_head->_next, x);
}
bool Empty()//判断是否为空
{
return _head->_next == _head;
}

void Print()
{
Node*cur = _head->_next;
while (cur!= _head)
{
cout << cur->_data << "";
cur = cur->_next;
}
cout << endl;
}
void Erase(Node*pos)
{
assert(pos&&pos != _head);
Node* prev = pos->_prev;
Node* next = pos->_next;
delete pos;

prev->_next = next;
next->_prev = prev;

}
void Insert(Node*pos, const T&x)
{
assert(pos);

Node*tmp = new Node(x);
Node*prev = pos->_prev;

prev->_next = tmp;
tmp->_prev = prev;

tmp->_next = pos;
pos->_prev = tmp;
}

Node* Find(const T &x)
{
Node*cur = _head->_next;
while (cur!=_head)
{
if (cur->_data == x)
{
return cur;
}
cur = cur->_next;
}
return NULL;
}
protected:
Node* _head;
};

顺序表

template<class T>
class Seqlist
{
public:
Seqlist()
:_a(NULL)
, _capacity(0)
, _size(0)
{}
Seqlist(Seqlist & s)
:_a(s._a)
, _capacity(s._capacity)
, _size(s._size)
{}
Seqlist& operator=(Seqlist&s)
{
swap(_a, s._a);
swap(_capacity, s._capacity);
swap(_size, s.size);
return *this;
}

void CheakCapacity()
{
if (_size == _capacity)
{
size_t Newsize = _size ? _capacity * 2 : 3;
_a = (T*)realloc(_a, Newsize*sizeof(T));
_capacity = Newsize;
}
}
void PushBack(const T &x)
{
CheakCapacity();
_a[_size++] = x;
}
void PopBack()
{
assert(_size);
--_size;

}
void PushFront(const T &x)
{
CheakCapacity();
int end = _size;
while (end>0)
{
_a[end] = _a[end - 1];
end--;
}
_a[0] = x;
++_size;
}
void PopFront()
{
assert(_a);
int n = 0;
while (n<_size-1)
{
_a
= _a[n + 1];
n++;
}
--_size;
}
~SeqList()
{
if (_a)
{
free(_a);

}
}
void Print()
{
for (size_t i = 0; i < _size; i++)
{
cout << _a[i] << " ";
}
cout << endl;
}
private:
T *_a;
size_t _capacity;
size_t _size;

};