链表的逆置

题目：输入一个链表的头节点，从头到尾反过来打印出每个节点的值

Reverse()函数：输入头结点，可输出的确是从尾到头；即第一个输入的节点，最后一个输出；最后一个输入的结点，第一个输出；很典型的“后进先出“；用桟实现；

1、将结点放进桟中，当结点全遍历一遍时，链表已经反过来，

2、此时再从桟顶逐个输出结点的值

Reverse2()函数：递归本质就是桟结构；则用_Reverse2(_head)函数去递归；Reverse2()函数自己递归不了自己，参数传不进去，则调用了另外一个函数_Reverse2(_head)；

Reverse3()函数：递归的代码是简单明了，但是当结点很多时，需要递归的层就太深了，效率就很低，所以用循环去实现；//摘结点；如下图1：

addLinkNode()函数：增加链表的结点；

deleteLinkNode()函数：删除某一个值为value的结点；

Print()函数：用循环去逆置时，才用此函数去打印；

测试用例：

Test()：测试的是Reverse();

Test2()：测试的是Reverse2();

Test3()：测试的是Reverse3();

三个测试用例的数据都为：3->4->5->7；则结果也都相同，为：7->5->4->3

代码如下：

#include<iostream>
#include<stack>
using namespace std;
struct LinkNode
{
	int _value;
	LinkNode* _next;

	LinkNode(int value = 0)
		:_value(value), _next(NULL)
	{}
};

class Link
{
private:
	void _Release()
	{
		while(_head != NULL)
		{
			LinkNode* begin = _head;
			_head = _head->_next;
			delete[] begin;
		}
	}
	void _ReverseLink2(LinkNode* &_head)
	{
		if (_head)
		{
			if (_head->_next)
			{
				_ReverseLink2(_head->_next );
			}
			cout << _head->_value << "->";
		}
	}

public:
	Link()
		:_head(NULL)
	{}

	~Link()
	{
		_Release();
	}

	void addLinkNode(int value)
	{
		//尾插
		//1.链表为空时
		//2.链表不为空时
		if (_head == NULL)
		{
			_head = new LinkNode(value);
		}
		else
		{
			LinkNode* tmp = new LinkNode(value);
			LinkNode* begin = _head;
			while (begin->_next != NULL)
			{
				begin = begin->_next;
			}
			begin->_next = tmp;
		}
	}

	void deleteLinkNode(int value)
	{
		//1.链表为空
		//2.链表的头结点，也是尾节点
		//3.链表的尾节点
		//4.链表的中间，不是尾节点
		if (_head == NULL)
		{
			cout << "Link is NULL!" << endl;
			return;
		}
		LinkNode* begin = _head;
		while (begin->_next != NULL && begin->_value != value)
			begin = begin->_next;
		if (begin->_next == NULL)
		{
			cout << "No Node!" << endl;
			return;
		}
		if (begin == _head && brgin->_next == NULL)
		{
			delete[] begin;
			_head = NULL;
		}
		else if (begin->_next == NULL)
		{
			delete[] begin;
			begin = NULL;
		}
		else
		{
			begin->_value = begin->_next->_value;
			LinkNode* tmp = begin->_next;
			begin->_next = begin->_next->_next;
			delete[] tmp;
		}
	}
	void ReverseLink()
	{
		stack<LinkNode*> node;
		LinkNode* begin = _head;
		while (begin)
		{
			node.push(begin);
			begin = begin->_next;
		}
		while (!node.empty())
		{
			cout << node.top()->_value << "->";
			node.pop();
		}
		cout << endl;
	}
	void ReverseLink2()
	{
		_ReverseLink2(_head);
	}
	void ReverseLink3()
	{
		//摘结点
		LinkNode* begin = _head;
		LinkNode* tmp = _head;
		LinkNode* newHead = NULL;
		while (begin)
		{
			begin = begin->_next;
			tmp->_next = newHead;
			newHead = tmp;
			tmp = begin;
		}
		_head = newHead;
	}

	void Print()
	{
		LinkNode* begin = _head;
		while (begin)
		{
			cout << begin->_value << "->";
			begin = begin->_next;
		}
		cout << endl;
	}

private:
	LinkNode* _head;
};

void Test()
{
	cout << "Test:" << endl;
	Link LK;
	LK.addLinkNode(2);
	LK.addLinkNode(3);
	LK.addLinkNode(4);
	LK.addLinkNode(5);
	LK.addLinkNode(6);
	LK.addLinkNode(7);
	LK.Print();

	LK.deleteLinkNode(2);
	LK.deleteLinkNode(6);
	LK.Print();

	LK.ReverseLink();
}

void Test2()
{
	cout << "Test2:" << endl;
	Link LK;
	LK.addLinkNode(2);
	LK.addLinkNode(3);
	LK.addLinkNode(4);
	LK.addLinkNode(5);
	LK.addLinkNode(6);
	LK.addLinkNode(7);
	LK.Print();

	LK.deleteLinkNode(2);
	LK.deleteLinkNode(6);
	LK.Print();

	LK.ReverseLink2();
}

void Test3()
{
	cout << "Test3:" << endl;
	Link LK;
	LK.addLinkNode(2);
	LK.addLinkNode(3);
	LK.addLinkNode(4);
	LK.addLinkNode(5);
	LK.addLinkNode(6);
	LK.addLinkNode(7);
	LK.Print();

	LK.deleteLinkNode(2);
	LK.deleteLinkNode(6);
	LK.Print();

	LK.ReverseLink3();
	LK.Print();
}


int main()
{
	Test();
	Test2();
	cout << endl;
	Test3();
	return 0;
}

结果如下图2：

图1：

图2：