【C++】实现双向链表的所有操作，包括逆置双链表(三种方法)

include "List.h"

int main()
{
Test();
system("pause");
return 0;
}

#ifndef __LISH_H__
#define __LISH_H__
#include<iostream>
using namespace std;

typedef int DataType;

struct ListNode
{
ListNode(DataType x)
:_next(NULL)
, _prev(NULL)
, _data(x)
{}

ListNode* _next;
ListNode* _prev;
DataType _data;
};

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

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

List& operator= (const List& s)
{
//先删除节点，再插入节点
if (&s != this)
{
ListNode* pcur = _head;
while (pcur)
{
ListNode* del = pcur;
pcur = pcur->_next;
delete del;
del = NULL;
}
ListNode* cur = s._head;
while (cur)
{
this->PushBack(cur->_data);
cur = cur->_next;
}
}
return *this;
}

~List()
{
ListNode* cur = _head;
while (cur)
{
ListNode* del = cur;
cur = cur->_next;
delete del;
del = NULL;
}
}

//尾插
void PushBack(DataType x)
{
//分：0节点   1、多节点两种情况
if (_head == NULL)
{
_head = new ListNode(x);
_tail = _head;
_tail->_next = NULL;
}
else
{
ListNode* cur = new ListNode(x);
_tail->_next = cur;
cur->_prev = _tail;
_tail = cur;
_tail->_next = NULL;
}
}

//尾删
void PopBack()
{
if (_head == _tail)
{
if (_head != NULL)
{
delete _head;
_head = NULL;
_tail = NULL;
}
else
{
return;
}
}
else
{
ListNode* prev = _tail->_prev;
delete _tail;
_tail = NULL;
_tail = prev;
_tail->_next = NULL;
}
}

//头插
void PushFront(DataType x)
{
if (_head == NULL)
{
PushBack(x);
}
else
{
ListNode* index = new ListNode(x);
index->_next = _head;
_head->_prev = index;
_head = index;
_head->_prev = NULL;
}
}

//头删
void PopFront()
{
if (_head == _tail)
{
PopBack();
}
else
{
ListNode* del = _head;
ListNode* next = _head->_next;
_head = next;
_head->_prev = NULL;
delete del;
del = NULL;
}
}

//插入元素
void Insert(size_t pos, DataType x)
{
//分：是尾插   不是尾插    两种情况
ListNode* cur = _head;
while (--pos)
{
cur = cur->_next;
}
if (cur == _tail)
{
PushBack(x);
}
else
{
ListNode* index = new ListNode(x);
ListNode* prev = cur->_prev;
index->_next = cur;
cur->_prev = index;
prev->_next = index;
index->_prev = prev;
}
}

//查找元素
ListNode* Find(DataType x)
{
ListNode* cur = _head;
while (cur)
{
if (cur->_data == x)
{
return cur;
}
cur = cur->_next;
}
return NULL;
}

//删除元素
void Erase(ListNode* pos)
{
if (pos == _head)
{
PopFront();
}
else if (pos == _tail)
{
PopBack();
}
else
{
ListNode* prev = pos->_prev;
ListNode* next = pos->_next;
prev->_next = next;
next->_prev = prev;
delete pos;
pos = NULL;
}
}

//逆置方法一：从两头走，交换数据
/*void Reverse()
{
ListNode* begin = _head;
ListNode* end = _tail;
while (!((begin == end) || (end->_next == begin)))
{
swap(begin->_data, end->_data);
begin = begin->_next;
end = end->_prev;
}
}*/

//逆置方法二：交换节点的前驱和后继
/*void Reverse()
{
ListNode* cur = _head;
while (cur)
{
swap(cur->_prev, cur->_next);
cur = cur->_prev;
}
swap(_head, _tail);
}*/

//逆置方法三：摘节点，头插该节点
void Reverse()
{
ListNode* cur = _head;
ListNode* newhead = NULL;
while (cur)
{
ListNode* tmp = cur;
cur = cur->_next;
if (newhead == NULL)
{
newhead = tmp;

newhead->_next = NULL;
newhead->_prev = NULL;
_head = _tail = newhead;
}
else
{
newhead->_prev = tmp;
tmp->_next = newhead;
newhead = tmp;
_head = newhead;
_head->_prev = NULL;
}
}
}

//打印
void PrintList()
{
ListNode* cur = _head;
while (cur)
{
cout << cur->_data << "->";
cur = cur->_next;
}
cout << "NULL" << endl;
}
private:
ListNode* _head;
ListNode* _tail;
};

void Test()
{
List s;
s.PushBack(1);
s.PushBack(2);
s.PushBack(3);
s.PushBack(4);
s.PushBack(5);
s.PrintList();

s.PopBack();
s.PrintList();

s.PushFront(0);
s.PrintList();

s.PopFront();
s.PrintList();

s.Insert(2, 10);
s.PrintList();

s.Reverse();
s.PrintList();

}

#endif //__LIST_H__