c++实现单链表,双向链表,顺序表的接口(非模板)

单链表

struct SListNode
{
SListNode* _next;
DataType _data;
SListNode(DataType x)
:_data(x)
,_next(NULL)
{}
};
class SList
{
typedef SListNode Node;
public:
SList()
:_head(NULL)
, _tail(NULL)
{}
SList(const SList& s)
:_head(NULL)
, _tail(NULL)
{
Node*cur = s._head;
while (cur->_next)
{
PushBack(cur->_data);
cur = cur->_next;
}
}
SList& operator=(const SList& s)
{
Node*tmp=_head;
if(tmp)
{
tmp=tmp->next;
delete _head;
_head=tmp;
}
_head=NULL;
Node*cur = s._head;
while (cur->_next)
{
PushBack(cur->_data);
cur = cur->_next;
}
}
~SList()
{
while (_head != _tail)
{
Node*tmp = _head;
delete[] _head;
_head = tmp;
}
delete[] _tail;
_head = _tail = NULL;
}
void PushBack(DataType x)
{
if (_head == NULL)
{
_head = _tail = new Node(x);
}
_tail->_next = new Node(x);
_tail = _tail->_next;
}
void PopBack()
{
if (_head == NULL)
return;
else if (_head = _tail)
{
delete _head;
_tail = _head = NULL;
}
else
{
Node*tmp = _head;
while (tmp->_next->_next)
{
tmp = tmp->_next;
}
delete[]_tail;
_tail = tmp;
_tail->_next = NULL;
}
}
void PushFront(DataType x)
{
Node*tmp = new Node(x);
tmp->_next = _head;
_head = tmp;
}
void PopFront()
{
if (_head == NULL)
return;
else if (_head = _tail)
{
delete _head;
_tail = _head = NULL;
}
else
{
Node*tmp = _head->_next;
delete[] _head;
_head = tmp;
}
}
// 插入一个节点在pos的前面
void Insert(Node* pos, DataType x)
{
if (_head == NULL)
{
_head = _tail = new Node(x);
}
else if (_head == _tail)
{
_head = new Node(x);
_head->_next = _tail;
}
else
{
Node *tmp = _head;
while (tmp->_next != pos)
{
tmp = tmp->_next;
}
Node*tail = new Node(x);
tmp->_next = tail;
tail->_next = pos;
}
}
void Erase(Node* pos)
{
if (_head == NULL)
return;
else if (_head = _tail)
{
delete[] _head;
_head = _tail = NULL;
}
else if (pos->_next == NULL)
{
PopBack();
}
Node *tmp = _head;
while (tmp->_next != pos)
{
tmp = tmp->_next;
}
tmp->_next = pos->_next;
delete[] pos;
}
void Print()
{
Node*tmp = _head;
while (tmp)
{
cout << tmp->_data;
}
cout << endl;
}

private:
Node* _head;
Node* _tail;
};

双向链表

typedef int DataType;
struct ListNode
{
ListNode* _next;
ListNode* _prev;
DataType _data;
ListNode(DataType x)
:_data(x)
, _next(NULL)
, _prev(NULL)
{}
};

class List
{
typedef ListNode Node;
public:
List()
: _head(NULL)
, _tail(NULL)
{}
List(const List&s)
:_head(NULL)
,_tail(NULL)
{
Node*cur = s._head;
while (cur->_next)
{
PushBack(cur->_data);
cur = cur->_next;
}
}

List& operator=(const List& s)
{
SList(const SList& s)
:_head(NULL)
, _tail(NULL)
{
Node*cur = s._head;
while (cur->_next)
{
PushBack(cur->_data);
cur = cur->_next;
}
}
SList& operator=(const SList& s)
{
Node*tmp=_head;
if(tmp)
{
tmp=tmp->next;
delete _head;
_head=tmp;
}
_head=NULL;
Node*cur = s._head;
while (cur->_next)
{
PushBack(cur->_data);
cur = cur->_next;
}
}
~List()
{
while (_head != _tail)
{
Node*tmp = _head;
delete[] _head;
_head = tmp;
}
delete[] _tail;
_head = _tail = NULL;
}
void PushBack(DataType x)
{
Insert(_tail, x);
}
void PopBack()
{
Erase(_tail);
}
void PushFront(DataType x)
{
Insert(_head, x);
}
void PopFront()
{
Erase(_head);
}
// 在pos的前面插入一个
void Insert(Node* pos, DataType x)
{
if (_head == NULL)
{
_head = _tail = new Node(x);
}
else if (_head == _tail)
{
_head = new Node(x);
_head->_next = _tail;
_tail->_prev = _head;
}
else
{
Node*tmp = new Node(x);
Node*prev = pos->_prev;
prev->_next = tmp;
tmp->_prev = prev;
tmp->_next = pos;
pos->_prev = tmp;
}
}
void Erase(Node* pos)
{
if (_head == NULL)
return;
else if (_head = _tail)
{
delete[] _head;
_head = _tail = NULL;
}
else if (pos->_next == NULL)
{
Node *tmp = pos->_prev;
delete[] _tail;
_tail = tmp;
}
else if (pos->_prev == NULL)
{
Node *tmp = pos->_next;
delete _head;
_head = tmp;
}
else
{
Node*prev = pos->_prev;
Node*next = pos->_next;
prev->_next = next;
next->_prev = prev;
delete[] pos;
}
}
Node* Find(DataType x)
{
Node*tmp = _head;
while (tmp)
{
if (tmp->_data == x)
{
return tmp;
}
tmp = tmp->_next;
}
return NULL;
}
void Reverse()
{
Node *tmp = _head;
Node *cur = _head;
while (_head)
{
cur->_next = _head->_prev;
cur->_prev = _head->_next;
_head = _head->_next;
}
_tail = tmp;
}
private:
Node* _head;
Node* _tail;
};

顺序表

typedef int DataType;

class SeqList
{
public:
SeqList(size_t size=1)
{
_array = (DataType*)malloc(sizeof(size)*size);
_size = size;
_capacity = size;
}
SeqList(const SeqList& s)
{
_array = (DataType*)malloc(_size);
for (size_t i = 0; i++; i < _size)
{
_array[i] = s._array[i];
}
_size = s._size;
_capacity = s._size;
}
~SeqList()
{
free (_array);
}
void Swap(SeqList s)
{
swap(_array, s._array);
_size = s._size;
_capacity = s._capacity;
}
void PushBack(DataType x)
{
CheckCapcacity();
_array[_size] = x;
_size++;
}
void PopBack()
{
_size--;
}
void PushFront(DataType x)
{
CheckCapcacity();
for (size_t i = _size; i--; i > 0)
{
_array[_size] = _array[_size - 1];
}
_array[0] = x;
}
void PopFront()
{
for (int i = 1; i++; i < _size)
{
_array[i] = _array[i - 1];
}
_size--;
}
void Insert(int pos, DataType x)
{
CheckCapcacity();
if (pos == 0)
{
PushFront(x);
}
else
{
for (int i = _size; i--; i > pos)
{
_array[i] = _array[i - 1];
}
_array[pos] = x;
}
_size++;
}
void Erase(size_t pos)
{
if (pos == _size - 1)
PopBack();
for (int i = pos; i++;i<_size)
{
_array[i] = _array[i + 1];
}
_size--;
}
DataType& operator[](size_t pos)
{
return _array[pos];
}
void CheckCapcacity()
{
if (_size = _capacity)
{
DataType*tmp = new DataType(_capacity * 2);
for (size_t i = 0; i <= _size; i++)
{
tmp[i] = _array[i];
}
swap(tmp, _array);
_capacity *= 2;
}
}
void Print()
{
for (size_t i = 0; i++; i < _size)
{
cout<<_array[i];
}
cout << endl;
}
private:
DataType* _array;
size_t _size;
size_t _capacity;
};