链表的翻转

如何快速的实现链表的翻转，比如链表A数据为

str1，str2,  str3,  str4,  str5,  str6

翻转后则变为

str6,  str5,  str4,  str3,  str2,  str1

针对上述问题我能想到的一种办法就是以压栈的方式来实现，其实现思路相对较为简单，

通过定义一个链表数据结构的数据栈，遍历链表，并将其压栈，完成后，栈中的链表数据

即为我们想要的结果了，我们只需进行出栈操作，并建立一个新的链表即可。

从叙述中可以得到，该方法需要额外的空间来存储数据，创建堆栈以及建立一个新的链表

至少需要2n个节点空间(如有n个节点)，这无疑增加了空间复杂度，此外，该算法需要经历一

此遍历、一次压栈、一次出栈以及创建一个新的链表，其时间开销也相对较大。如何才能减少

其执行的时间以及所需的空间呢？

我们知道链表的创建可以有两种方式：头插法和尾插法。这给了我们一个提示，当我们在翻转

链表时，如果在遍历链表时通过头插法将链表重新插入，此时链表不就是逆序了么？此时我们

不需要增加任何节点，只需要几个节点指针就可以完成，同时，我们只需要进行一次链表的遍

历即可以完成链表的翻转。

考虑到第一种实现方式较为复杂，在这里就给出第二种方式的代码。

#include <iostream>

typedef int Type;
typedef struct Node {
	Type data;
	struct Node *next;
}ListNode;

void InitList(ListNode* &L, Type* arr, int size) {
     L = new ListNode;
	 L->next = NULL;
	 ListNode* last = L;
	 int i = 0;
	 while (i < size) {
		 ListNode* tmp = new ListNode;
		 tmp->data = arr[i];
		 tmp->next = NULL;
		 last->next = tmp;
		 last = tmp;
		 ++i;
	 }
}

void Display(ListNode* &L) {
	ListNode* tmp = L->next;
	int i = 0;
	while (tmp) {
		std::cout <<tmp->data <<" ";
		if ((++i) % 10 == 0) {
			std::cout <<std::endl;
		}
		tmp = tmp->next;
	}
	std::cout <<std::endl;
}


void Reverse(ListNode* &L) {
	ListNode* first = NULL, *current = NULL, *tmp = NULL;
	first = L->next;               // first用于保存逆序的链表当中的第一个节点
	current = first->next;         // current用于保存目前处理的节点
	first->next = NULL;            // 一定要置为NULL，否则可能导致循环
	while (current) {
		tmp = current->next;   // 利用一个临时指针来保存下一个待处理的节点
		current->next = first; // 将当前节点插入到逆序节点的第一个节点之前，并更改first指向
		first = current;
		L->next = first;       // 使链表头指针指向逆序后的第一个节点
		current = tmp;         // 更新待处理的节点
	}
}


int main() {
	Type arr[] = {
		12, 13, 14, 15, 16, 17, 18, 19, 20
	};
	ListNode* head = NULL;
	InitList(head, arr, sizeof(arr) / sizeof(int));
	std::cout <<"Before Reverse:" <<std::endl;
	Display(head);
	Reverse(head);
	std::cout <<"After Reverse:" <<std::endl;
	Display(head);
	return 0;
}

执行结果如下图所示：