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

建立源文件List.cppinclude "List.h"

int main()

{

Test();

system("pause");

return 0;

}

建立头文件List.h#ifndef __LISH_H__

#define __LISH_H__

#include

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 <_data <";

cur = cur->_next;

}

cout <

}

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__

原文：http://10740184.blog.51cto.com/10730184/1747880