单链表逆序

   之前面试时遇到一个算法题，求单链表的逆序，当时首先想到新建一个链表，然后通过头插法把现有链表的内容复制到新链表内，不过这个方法的空间复杂度为S（n），非常高。面试官就说为什么不用一个临时节点和头插法结合使链表逆序，我当时想不出来。后来琢磨了一下，大致思路如下：

    新建临时节点，从输入链表的头结点开始遍历，通过头插法，把原有链表的节点进行重新指向，达到逆序的结果：

Node* ListRevise(Node *head)				//输入参数是链表的头结点，返回参数是逆序后的链表的头结点
{
	Node *prev = (Node*)malloc(sizeof(Node));	//prev（用于头插法的指向节点）
	Node *next = (Node*)malloc(sizeof(Node));	//next（用于存放原链表当前节点的下一节点）
	while (head!= NULL)				//当原链表头结点不为空时，进行遍历
	{
		next = head->next;			//先获取当前节点的下一节点信息，进行保存
		head->next = prev;			//通过头插法把当前节点重新指向临时节点，进行逆序
		prev = head;				//由于每一次都是对着prev节点进行指向，所以需要把头结点的值赋给prev节点，用于进行下一次指向
		head = next;				//原链表的头指针向后移一位
	}
	return prev;					//返回逆序后的链表的头结点
}

    整体测试代码如下（使用VS2013+win7，已经上机运行及测试通过）：

#include <iostream>
using namespace std;

/*本次测试所用的节点结构体*/
typedef struct Node
{
	int data;
	struct Node *next;		//指向Node结构体的指针
};

/*建立一个临时指针，使用头插法把元素逆序*/
Node* ListRevise(Node *head)
{
	Node *prev = (Node*)malloc(sizeof(Node));
	Node *next = (Node*)malloc(sizeof(Node));
	while (head!= NULL)
	{
		next = head->next;
		head->next = prev;
		prev = head;
		head = next;
	}
	return prev;
}

int main()
{   	
		Node *L,*p;
	Node *temp=(Node*)malloc(sizeof(Node));
	int i = 0;
	L = (Node*)malloc(sizeof(Node)); 
	L->next = NULL;					//L是头指针
	
	/*进行初始化*/
	for (i = 0; i < 10; i++)			
	{
		p = (Node*)malloc(sizeof(Node));
		p->data = i;
		p->next = L->next;
		L->next = p;
	}
	p = L->next;
	
	/*遍历逆序前的单链表*/
	for (i = 0; i < 10; i++)
	{
		cout << p->data<<endl;
		p = p->next;
	}

	p = L->next;			//重新指向链表的头结点
	temp=ListRevise(p);		//调用链表逆序函数，并把逆序后的链表的节点信息赋值给temp节点

	cout << "````````````````````" << endl;

	/*遍历逆序后的单链表*/
	for (i = 0; i < 10; i++)
	{
		cout << temp->data << endl;
		temp = temp->next;
	}
	
	system("pause");
	return 0;
}