简单实现单链表

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

typedef int DataType;

struct LinkNode
{
DataType _data;
LinkNode* _next;

LinkNode(const DataType& x)
:_data(x)
,_next(NULL)
{}
};

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

~SList()
{
Destory();
}

SList(const SList& s)
:_head(NULL)
,_tail(NULL)
{
if (s._head == NULL)
return;

LinkNode* begin = s._head;
do {
this->PushBack(begin->_data);
begin = begin->_next;
}while(begin != s._head);
}

void Swap(SList& s)
{
swap(_head, s._head);
swap(_tail, s._tail);
}

SList&operator=(const SList& s)
{
if (&s != this)
{
SList tmp(s);
Swap(tmp);
}

return *this;
}

void Destory()
{
if (_head == NULL)
return;

LinkNode* begin = _head;
do{
LinkNode* del = begin;
begin = begin->_next;
delete del;
}while(begin != _head);

_head = NULL;
_tail = NULL;
}

public:
void Print()
{
if (_head == NULL)
return;

LinkNode* begin = _head;
do{
cout<<begin->_data<<"->";
begin = begin->_next;
}while(begin != _head);

cout<<endl;
}

void PushBack(const DataType& x)
{
// 1.空链表
// 2.有一个或一个以上节点
if(_head == NULL)
{
_head = new LinkNode(x);
_tail = _head;
_tail->_next = _head;
}
else
{
_tail->_next = new LinkNode(x);
_tail = _tail->_next;
_tail->_next = _head;
}
}

void PopBack()
{
//1.没有节点
//2.一个节点
//3.两个或两个以上的节点
if(_head == NULL)
{
return;
}
else if(_head == _tail)
{
delete _head;
_head = NULL;
_tail = NULL;
}
else
{
LinkNode* prev = _head;
while (prev->_next != _tail)
{
prev = prev->_next;
}
prev->_next = _head;
delete _tail;
_tail = prev;
}
}

void PushFront(const DataType& x)
{
// 1.链表为空
if (_head == NULL)
{
_head = new LinkNode(x);
_tail = _head;
_tail->_next = _head;
}
else
{
LinkNode* tmp=new LinkNode(x);
tmp->_next=_head;
_head = tmp;
_tail->_next=_head;
}
}

void PopFront()
{
// 1.没有节点
if(_head == NULL)
{
return;
}
else if(_head == _tail)
{
delete _head;
_head = NULL;
_tail = NULL;
}
else
{

LinkNode* del = _head;
_head = _head->_next;
delete del;
_tail->_next = _head;
}
}

LinkNode* Find (DataType x)
{
LinkNode* begin = _head;
while(begin)
{
if (begin->_data == x)
{
return begin;
}

begin = begin->_next;

if (begin == _head)
{
break;
}
}

return NULL;
}

bool Remove (LinkNode * n)
{
assert(n);

// 1.链表为空
if (_head == NULL)
{
return false;
}

// 2.只有一个节点
if(_head == _tail)
{
if (n == _head)
{
delete _head;
_head = NULL;
_tail = NULL;
return true;
}

return false;
}

// 3.两个以上的节点
LinkNode* prev = _head;
while (prev->_next != n)
{
prev = prev->_next;

// 如果没有找到n,则返回false。
if (prev == _head)
{
return false;
}
}

if (n == _head)
{
_head = _head->_next;
delete n;
_tail->_next = _head;
}
else if (n == _tail)
{
prev->_next = _head;
_tail = prev;
delete n;
}
else
{
prev->_next = n->_next;
delete n;
}

return true;
}

void Reverse()
{
if (_head == NULL)
return;

LinkNode* newHead = NULL, *newTail = _head;
LinkNode* begin = _head;
while (1)
{
LinkNode* tmp = begin;
begin = begin->_next;
tmp->_next = newHead;
newHead = tmp;

if (begin == _head)
{
break;
}
}

_head = newHead;
_tail = newTail;
_tail->_next = _head;
}

void Insert (LinkNode * n, DataType x)
{
if(_head == NULL)
{
cout<<"链表为空,正在为您创建新链表"<<endl;
_head = new LinkNode(x);
_tail = _head;
_tail->_next = _head;
}
else if(n == NULL)
{
cout<<"找不到该节点，请重新输入节点插入"<<endl;
return;
}
else if(_head == _tail)
{
if(n == _head || n == _tail)
{
LinkNode *tmp = _head;
_head = new  LinkNode(x);
_head->_next = tmp;
_tail = tmp;
_tail->_next = _head;
}
else
{
cout<<"找不到该节点，请重新输入节点插入"<<endl;
return;
}
}
else//两个以上节点
{
LinkNode* begin = _head;
while(begin->_next != n)
{
begin = begin->_next ;
if(begin == _head)//没有找到该节点
{
cout<<"找不到该节点，请重新输入节点插入"<<endl;
return ;
}
}
if(n == _head)
{
LinkNode *tmp = _head;
_head = new LinkNode(x);
_head->_next = tmp;
_tail->_next = _head;
}
else if(n == _tail)
{
LinkNode *tmp = _tail;
_tail = new LinkNode(x);
tmp->_next = _tail;
_tail->_next = _head;
}
else
{
LinkNode *tmp  = new LinkNode(x);
begin->_next = tmp;
tmp->_next = n;
}

}
}
void Erase (DataType x)
{
LinkNode *begin = _head;
LinkNode *tmp = begin;
while(begin->_data != x)
{
tmp = begin;
begin = begin->_next ;
if(begin == _head)
{
cout<<"没有此元素，无法删除"<<endl;
}
}
if(begin == _head)
{
_head = _head->_next;
_tail->_next = _head;
}
else if(begin == _tail)
{
_tail = tmp;
_tail->_next = _head;
}
else
{
tmp->_next = begin->_next ;
}
//delete tmp;
//delete begin;

}
private:
LinkNode* _head;	// 指向链表头的指针
LinkNode* _tail;	// 指向链表尾的指针
};

void Test1()
{
SList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.Print();

s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.PopBack();
s1.Print();
}

void Test2()
{
SList s1;
s1.PushFront(1);
s1.PushFront(2);
s1.PushFront(3);
s1.PushFront(4);
s1.Print();

s1.PopFront();
s1.PopFront();
s1.PopFront();
s1.PopFront();
s1.PopFront();
s1.Print();
}

void Test3()
{
SList s1;
s1.PushBack(1);
//s1.PushBack(2);
//s1.PushBack(3);
//s1.PushBack(4);
s1.Print();

LinkNode* ret = s1.Find(1);
cout<<"ret:"<<ret->_data<<endl;

ret = s1.Find(5);
cout<<"ret:"<<ret<<endl;
}

void Test4()
{
SList s1;
s1.PushBack(1);
s1.PushBack(2);
s1.PushBack(3);
s1.PushBack(4);
s1.Print();

SList s2;
s2 = s1;
s2.Print();

s2.Reverse();
s2.Print();
}

int main()
{
//Test1();
//Test2();
//Test3();

Test4();
system("pause");
return 0;
}