【C++】c++实现线性表、链表

c++实现动态顺序表如下

typedef int DataType;
class SeqList
{
public:
//////////////类的基本成员函数定义/////////////////
SeqList()                     //构造函数（在类内定义）
:_elem(NULL)
, _capacity(0)
, _size(0)
{}
~SeqList()                  //析构函数
{
if (_elem)
{
delete[] _elem;
cout << "~SeqList()" << endl;
}
}
SeqList(const SeqList& s)    //拷贝构造函数
:_elem(new DataType[s._capacity])
, _capacity(s._capacity)
, _size(s._size)
{
memcpy(_elem, s._elem, _size*sizeof(DataType));
}
SeqList& operator= (const SeqList& s)  //赋值操作符重载
{
if (this != &s)  //防止自赋值
{
delete[] _elem;//释放原来空间
_elem = new DataType[s._capacity];//分配新空间
memcpy(_elem, s._elem, s._size*sizeof(DataType));
_size = s._size;
_capacity = s._capacity;
}
return *this;
}
//////////动态顺序表的基本操作实现///////////////
void _CheckCapacity();         //在类外定义
void _PrintSeqList();
void _PushBack(DataType data);
void _PopBack();
size_t Find(DataType data);
void Insert(size_t index,DataType data);
private:
DataType* _elem;   //指向当前空间的指针
size_t _capacity;     //当前空间容量大小
size_t _size;          //但钱空间有效数据的个数
};

类外定义成员函数如下：

void SeqList::_CheckCapacity()         //检查容量
{
if (_size == _capacity)
{
_capacity = _capacity * 2 + 5;//构造函数初始化时，_capacity为0
DataType* ret = (DataType*)malloc(_capacity*sizeof(DataType));
memcpy(ret, _elem, _size*sizeof(DataType));
delete[] _elem;
_elem = ret;
}
}
void SeqList::_PrintSeqList()
{
cout << "SeqList : ";
size_t index = 0;
for (; index < _size; index++)
{
cout << _elem[index] << " ";
}
cout << "NULL" << endl;
}
void SeqList::_PushBack(DataType data) //尾插数据
{
_CheckCapacity();
_elem[_size++] = data;
}
void SeqList::_PopBack()
{
if (_size == 0)
{
cout << "SeqList Is Empty" << endl;
return;
}
_size--;
}
size_t SeqList::Find(DataType data)    //查找数据，返回下标
{
size_t index = 0;
for (; index < _size; index++)
{
if (_elem[index] == data)
{
return index;
}
}
return _size+1;
}
void SeqList::Insert(size_t index, DataType data) //在下标index处插入一个数据
{
_CheckCapacity();
if (index > _size)
{
cout << "Invaid index" << endl;
return;
}
int i = _size-1;
for (; i >=(int)index; i--)  //注意此处i不能定义为size_t,且index要强转成int型，否则会成死循环
{                            //即使i一直减，但是无符号整型永远不会小于0，
_elem[i+1] = _elem[i];
}
_elem[index] = data;
_size++;
}

基本成员函数（如构造、拷贝构造、赋值操作符重载函数）还可以优化如下：

class SeqList
{
public:
//////////////类的基本成员函数定义/////////////////
SeqList(DataType* elem, size_t capacity, size_t size)   //构造函数
{
if (elem == NULL)
{
_elem = NULL;
_capacity = 0;
_size = 0;
}
else
{
_elem = new DataType[capacity];
memcpy(_elem, elem, size*sizeof(DataType));
_capacity = capacity;
_size = size;
}
}
~SeqList()                  //析构函数
{
if (_elem)
{
delete[] _elem;
cout << "~SeqList()" << endl;
}
}
void Swap(SeqList& s)
{
swap(_elem, s._elem);//自动调用系统实现的swap函数
swap(_capacity, s._capacity);
swap(_size, s._size);
}
SeqList(const SeqList& s)    //拷贝构造函数
:_elem(NULL)
, _capacity(0)
, _size(0)
{
SeqList tmp(s._elem, s._capacity, s._size);//通过构造函数进行初始化
Swap(tmp);  //将tmp与this的值交换，交换后this会指向原来tmp指向的空间
}
SeqList& operator= (const SeqList& s)  //赋值操作符重载
{
if (this != &s)  //防止自赋值
{
SeqList tmp(s._elem, s._capacity, s._size);
Swap(tmp);
}
return *this;
}
private:
DataType* _elem;   //指向当前空间的指针
size_t _capacity;     //当前空间容量大小
size_t _size;          //但钱空间有效数据的个数
};

解析：

SeqList tmp(s._elem, s._capacity, s._size);

Swap(tmp);

若已经存在的两个对象s1、s2；执行 s1 = s2 操作，则先创建一个临时对象tmp，将s2的值拷贝给tmp，再将tmp和s1的值进行交换，最后出了作用域就会释放这个临时对象tmp。如下图：

c++实现链表如下

单向循环链表

先了解：

关键字struct和class是同一等级的，

唯一区别是struct定义的成员默认是公有的，而class默认的成员是私有的

typedef int DataType;
struct LinkNode
{
LinkNode* _next;     //指向下一个节点的指针
DataType _data;  //当前节点的数据
LinkNode(const DataType data)    //构造函数
:_next(NULL)
,_data(data)
{}
};

class sList
{
public:
sList()                        //构造函数
:_head(NULL)
,_tail(NULL)
{}
sList(const sList& s)         //拷贝构造函数
:_head(NULL)
,_tail(NULL)
{
if(s._head == NULL)
{
return;
}
LinkNode* begin = s._head;
do
{
PushBack(begin->_data);  //this->PushBack(begin->_data);
begin = begin->_next;
} while (begin != s._head);
}
sList& operator= (const sList& s)   //赋值操作符重载
{
if (this != &s)
{
DistorysList();//先摧毁this指向的链表
LinkNode* begin = s._head;
do
{
PushBack(begin->_data);
begin = begin->_next;
} while (begin != s._head);
}
return *this;
}
~sList()                       //析构函数
{
Distory();
}
void DistorysList()            //撤销链表
{
while (_head)
{
PopBack();
}
}
void PushBack(DataType data)    //尾插
{
if (_head == NULL)
{
_head = new LinkNode(data);
_tail = _head;   //循环链表
}
else
{
_tail->_next = new LinkNode(data);
_tail = _tail->_next;
_tail->_next = _head;
}
}
void PopBack()                  //尾删
{
if (_head == NULL)//空链表
{
return;
}
if (_head == _tail)//一个节点
{
delete _head;
_head = NULL;
_tail = NULL;
}
else               //多个节点
{
LinkNode* prev = _head;
while (prev->_next != _tail)
{
prev = prev->_next;
}
delete _tail;
_tail = prev;
_tail->_next = _head;
}
}
void PrintsList()                  //打印链表
{
cout << "sList->";
if (_head != NULL)
{
LinkNode* begin = _head;
do
{
cout << begin->_data << "->";
begin = begin->_next;
}while (begin != _head);
}
cout << "NULL" << endl;
}
void Reverse()               //逆置链表
{
if (_head == NULL || _head == _tail)
{
return;
}
LinkNode* begin = _head->_next;
_head->_next = NULL;//摘下头节点
_tail->_next = NULL;//解开循环
_tail = _head;      //原来的头节点逆置后是尾节点
while (begin)
{
LinkNode* ret = begin;
begin = begin->_next;
ret->_next = _head;
_head = ret;
}
_tail->_next = _head;
}
private:
LinkNode* _head;   //指向头节点的指针
LinkNode* _tail;   //指向尾节点的指针
};

双向循环链表

typedef int DataType;
class DoubleNode
{
friend class DoubleList;        //友元函数
public:
DoubleNode(DataType data)       //构造函数
:_prev(NULL)
, _next(NULL)
, _data(data)
{}
private:
DoubleNode* _prev;
DoubleNode* _next;
DataType _data;
};

class DoubleList
{
public:
DoubleList()               //构造函数
:_head(NULL)
, _tail(NULL)
{}
DoubleList(const DoubleList& d) //拷贝构造函数
:_head(NULL)
, _tail(NULL)
{
if (d._head == NULL)
{
return;
}
DoubleNode* begin = d._head;
do
{
PushBack(begin->_data);
begin = begin->_next;
}while (begin != d._head);
}
DoubleList& operator= (const DoubleList& d)    //赋值操作符重载
{
if (this != &d)
{
Distory();
DoubleNode* begin = d._head;
do
{
PushBack(begin->_data);
begin = begin->_next;
} while (begin != d._head);
}
return *this;
}
~DoubleList()                       //析构函数
{
Distory();
}
void Distory()                   //摧毁链表
{
while (_head)
{
PopFront();
}
}
void PushBack(DataType data)     //尾插
{
if (_head == NULL)
{
_head = new DoubleNode(data);
_tail = _head;
}
else
{
DoubleNode* ret = new DoubleNode(data);
_tail->_next = ret;
ret->_prev = _tail;
_tail = ret;
_tail->_next = _head;   //成环
}
}
void PopFront()              //头删
{
if (_head == NULL)
{
cout << "DoubleList Is Empty" << endl;
}
else if (_head == _tail)
{
delete _head;
_head = NULL;
_tail = NULL;
}
else
{
DoubleNode* del = _head;
_head = _head->_next;
_head->_prev = NULL;
_tail->_next = _head;//更新尾指针
del->_next = NULL;
delete del;
}
}
void PrintDList()
{
cout << "DoubleList->";
if (_head != NULL)
{
DoubleNode* begin = _head;
do
{
cout << begin->_data << "->";
begin = begin->_next;
} while (begin != _head);
}
cout << "NULL" << endl;
}
private:
DoubleNode* _head;    //指向尾节点的指针
DoubleNode* _tail;    //指向头节点的指针
};