顺序表
#include<iostream>
using namespace std;
#include<string>
#include<assert.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning( disable : 4996)
template<typename T>
class SeqList
{
public:
SeqList()
:_data(NULL)
, _size(0)
, _capacity(0)
{}
/*SeqList(const T& s)
:_data(s._data)
, _size(s._size)
, _capacity(s._capacity)
{}
SeqList& operator=(SeqList& s)
{
}*/
T& operator[](size_t pos)
{
assert(pos < _size);
return _data[pos];
}
~SeqList()
{
if (_data)
{
delete[] _data;
_size = _capacity = 0;
_data = NULL;
}
}
void CheckCapacity()
{
size_t NewSize = _size ? _size * 2 : 3;
T* tmp = new T[NewSize];
for (size_t i = 0; i < _size; ++i)
{
tmp[i] = _data[i];
}
delete[] _data;
_data = tmp;
_capacity = NewSize;
}
void PushBack(const T& x)
{
CheckCapacity();
_data[_size] = x;
++_size;
}
void PopBack()
{
assert(_size);
}
void Insert(size_t pos, const T& x)
{
assert(pos);
assert(_size);
CheckCapacity();
for (size_t end = pos; end > pos; ++end)
{
_data[end] = _data[end + 1];
}
_data[pos] = x;
_size++;
}
void Erase(size_t pos)
{
assert(pos);
for (size_t i = pos; i < _size; ++i)
{
_data[i - 1] = _data[i];
}
}
void Print()
{
for (size_t i = 0; i < _size; ++i)
{
cout << _data[i]<<" ";
}
cout << endl;
}
private:
T* _data;
int _size;
int _capacity;
};
双向链表
#include<iostream>
using namespace std;
#include<string>
#include<assert.h>
#define _CRT_SECURE_NO_WARNINGS
#pragma warning( disable : 4996)
template<typename T>
struct ListNode
{
T _data;
ListNode* _prev;
ListNode* _next;
ListNode(T x)
:_data(x)
, _prev(NULL)
, _next(NULL)
{}
};
template<typename T>
class List
{
typedef ListNode<T> Node;
public:
List()
{
_head = new Node(T());
_head->_next = _head;
_head->_prev = _head;
}
~List()
{
Node* cur = _head;
while (cur->_next!=_head)
{
Node* next = cur->_next;
delete cur;
cur = next;
}
_head->_next = _head;
_head->_prev = _head;
}
void PushBack(const T& x)
{
Insert(_head, x);
}
void PopBack()
{
Erase(_head->_prev);
}
void PushFront(const T& x)
{
Insert(_head->_next, x);
}
void PopFront()
{
Erase(_head->_next);
}
void Insert(Node* pos, const T& x)
{
assert(pos);
Node* prev = pos->_prev;
Node* tmp = new Node(x);
prev->_next = tmp;
tmp->_next = pos;
pos->_prev = tmp;
tmp->_prev = prev;
}
void Erase(Node* pos)
{
Node* prev = pos->_prev;
Node* next = pos->_next;
prev->_next = next;
next->_prev = prev;
delete pos;
}
void Print()
{
Node* tmp = _head->_next;
while (tmp != _head)
{
cout << tmp->_data<<"->";
tmp = tmp->_next;
}
cout << endl;
}
private:
Node* _head;
};