C++简单实现顺序表与单链表

顺序表：

#include <assert.h>
#include <iostream>
using namespace std;

typedef int Datatype;

class SeqList
{
public:
SeqList()
:_array(NULL)
,_size(0)
,_capacity(0)
{
}

SeqList(const SeqList& s)
{
_array = (Datatype*)malloc(s._size*(sizeof(Datatype)));
memcpy(_array, s._array, s._size*(sizeof(Datatype)));
_size = _capacity = s._size;
}

SeqList& operator=(SeqList& s)
{
free(_array);
Swap(s);
return *this;
}

void Swap(SeqList& s)
{
_array = s._array;
_size = s._size;
_capacity = s._capacity;
}

~SeqList()
{
if (_array)
{
free(_array);
_array = NULL;
_size = _capacity = 0;
}
}

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

void CheckCapcacity()
{
if (_size == _capacity)
{
_capacity = 2 * _capacity + 3;
_array = (Datatype*)realloc(_array, _capacity*sizeof(Datatype));
assert(_array);
}
}

//后插
void PushBack(Datatype x)
{
Insert(_size, x);
}

//前插
void PushFront(Datatype x)
{
Insert(0, x);
}

//删除最后一个
void PopBack()
{
Erase(_size);
}

//删除第一个
void PopFront()
{
Erase(0);
}

//[]运算符重载
Datatype& operator[](size_t pos)
{
assert(pos < _size);
return _array[pos];
}

//pos位置前插入x
void Insert(size_t pos, Datatype x)
{
assert(pos <= _size);
CheckCapcacity();
int end = (int)_size - 1;
if (pos == 0)
{
while (end >= 0)
{
_array[end + 1] = _array[end];
end--;
}
_array[0] = x;
}
else
{
while (end >= (int)pos)
{
_array[end + 1] = _array[end];
end--;
}
_array[pos] = x;
}
_size++;
}

//删除pos位置的元素
void Erase(size_t pos)
{
assert(pos < _size);
//popfront的实现
if (_size > 0)
{
if (pos == 0)
{
int end = 0;
while (end < (int)_size - 1)
{
_array[end] = _array[end + 1];
end++;
}
_size--;
}
//popback的实现
else if (pos == _size)
{
_size--;
}
//erase
else
{
int end = pos;
while (end < (int)_size - 1)
{
_array[end] = _array[end + 1];
end++;
}
_size--;
}
}
return;
}

private:
Datatype* _array;
size_t  _size;
size_t _capacity;
};

单链表（不含头结点）

#include <iostream>
#include <assert.h>
using namespace std;

typedef int DataType;

struct SListNode
{
SListNode* _next;
DataType _data;

SListNode(DataType x)
:_data(x)
, _next(NULL)
{}
};

typedef SListNode Node;

class SList
{
public:
SList()
:_head(NULL)
, _tail(NULL)
{}

SList(const SList& s)
:_head(NULL)
,_tail(NULL)
{
Copy(s);
}

SList& operator=(const SList& s)
{
Destroy();
Copy(s);
return *this;
}

~SList()
{
Destroy();
}

void Copy(const SList& s)
{
Node* cur = s._head;
while (cur)
{
PushBack(cur->_data);
cur = cur->_next;
}
}

void Destroy()
{
Node* cur = _head;
while (_head != NULL)
{
cur = _head;
_head = cur->_next;
delete cur;
}
_head = _tail = NULL;
}

void PushBack(DataType x)
{
if ((_head == NULL)&&(_tail == NULL))
{
_head = _tail = new Node(x);
}
else
{
_tail->_next = new Node(x);
_tail = _tail->_next;
}
}

void PopBack()
{
if (_head == NULL)
{
return;
}
else if (_head ->_next == NULL)
{
delete _head;
_head = _tail = NULL;
}
else
{
Node* tmp = _head;
while (tmp->_next->_next != NULL)
{
tmp = tmp->_next;
}
_tail = tmp;
tmp->_next = NULL;
}
}

void PushFront(DataType x)
{
if ((_head == NULL) && (_tail == NULL))
{
_head = _tail = new Node(x);
}
else
{
Node* tmp = new Node(x);
tmp->_next = _head;
_head = tmp;
}
}

void PopFront()
{
if (_head == NULL)
{
return;
}
Node* cur = _head;
_head = _head->_next;
delete cur;
}

Node* Find(DataType x)
{
Node* tmp = _head;
while (tmp)
{
if (tmp->_data == x)
return tmp;
tmp = tmp->_next;
}
return NULL;
}

// 插入一个节点在pos的前面
void Insert(Node* pos, DataType x)
{
assert(pos);
if (pos == 0)
{
PushFront(x);
}
else
{
Node* cur = _head;
while (cur->_next != pos)
{
cur = cur->_next;
}
Node* tmp = new Node(x);
tmp->_next = pos;
cur->_next = tmp;
}
}

void Erase(Node* pos)
{
assert(pos);
if (pos == 0)
{
PopFront();
}
else if (pos->_next == NULL)
{
PopBack();
}
else
{
Node* cur = _head;
while (cur->_next != pos)
{
cur = cur->_next;
}
Node* tmp = cur->_next;
cur->_next = tmp->_next;
delete tmp;
}
}

void Print()
{
Node* tmp = _head;
while (tmp != NULL)
{
cout <<tmp->_data << "->";
tmp= tmp->_next;
}
cout <<"NULL"<<endl;
}

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