微软诉东莞网吧侵权案上调索赔金额

题目：输入一个链表的头节点，反转这个链表，并返回反转后链表的头节点，链表定义如下：
struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};
解答：
算法一：我们需要额外的两个变量来存储当前节点pCurrent的上一个节点pPrev和下一个节点pNext。假设经过若干次操作，我们将当前节点pCurrent之前的指针都反转完成，这些节点的m_pNext指针都指向前面的一个节点。现在我们遍历到pCurrent，这时需要调整该节点的m_pNext指针使其指向pPrev节点。但要注意调整了m_pNext指针的指向后，后面的链表就会断开，因此我们需要在调整pCurrent的m_pNext指针之前先将pNext节点保存下来。反转后的头节点就是原来的尾节点。
核心代码如下：
//反转链表核心算法
ListNode* ReverseList(ListNode* pHead)
{
ListNode* pReverseHead = NULL;
ListNode* pNode = pHead->m_pNext;
ListNode* pPrev = NULL;

while(pNode != NULL)
{
//存储当前节点pNode的下一个节点
ListNode* pNext = pNode->m_pNext;

//如果下一个节点为空，那么当前节点pNode就是反转后的头指针了
if(pNext == NULL)
{
pReverseHead = pNode;
}

//将当前节点改为指向pPrev节点
pNode->m_pNext = pPrev;

//移动两个指针
pPrev = pNode;
pNode = pNext;
}
//添加头指针
ListNode* pReturn = (ListNode*)malloc(sizeof(ListNode));
pReturn->m_pNext = pReverseHead;
return pReturn;
}

算法二：递归法，基本思想是在反转当前节点之前先调用递归函数反转后续节点，该方法在反转后的最后一个节点会形成一个环，所以必须将函数的返回节点的m_pNext域置为NULL。
ListNode* ReverseLink(ListNode* pHead)
{
if(pHead->m_pNext == NULL)
return pHead;
ListNode* pReturn = ReverseLink(pHead->m_pNext);
pHead->m_pNext->m_pNext = pHead;
pHead->m_pNext = NULL;
return pReturn;
}

//反转链表的递归算法
ListNode* ReverseList2(ListNode* pHead)
{
ListNode* pReverseHead = pHead;
//考虑只有0个或1个节点
if(pHead->m_pNext == NULL || pHead->m_pNext->m_pNext == NULL)
{
return pHead;
}
pReverseHead->m_pNext = ReverseLink(pReverseHead->m_pNext);
return pReverseHead;
}

完整测试代码如下：
#include <iostream>

struct ListNode
{
int m_nKey;
ListNode* m_pNext;
};

void InitList(ListNode** head)
{
*head = (ListNode*)malloc(sizeof(ListNode));
(*head)->m_pNext = NULL;
}

void InsertList(ListNode* head, int data)
{
assert(head != NULL);
ListNode* pNewNode = (ListNode*)malloc(sizeof(ListNode));
pNewNode->m_nKey = data;
pNewNode->m_pNext = head->m_pNext;
head->m_pNext = pNewNode;
}

void PrintList(ListNode* pHead)
{
if(pHead == NULL)
{
return;
}

ListNode* pTempNode = pHead->m_pNext;
while(pTempNode != NULL)
{
std::cout<<pTempNode->m_nKey<<std::endl;
pTempNode = pTempNode->m_pNext;
}
}

//反转链表核心算法
ListNode* ReverseList(ListNode* pHead)
{
ListNode* pReverseHead = NULL;
ListNode* pNode = pHead->m_pNext;
ListNode* pPrev = NULL;

while(pNode != NULL)
{
//存储当前节点pNode的下一个节点
ListNode* pNext = pNode->m_pNext;

//如果下一个节点为空，那么当前节点pNode就是反转后的头指针了
if(pNext == NULL)
{
pReverseHead = pNode;
}

//将当前节点改为指向pPrev节点
pNode->m_pNext = pPrev;

//移动两个指针
pPrev = pNode;
pNode = pNext;
}
//添加头指针
ListNode* pReturn = (ListNode*)malloc(sizeof(ListNode));
pReturn->m_pNext = pReverseHead;
return pReturn;
}

ListNode* ReverseLink(ListNode* pHead)
{
if(pHead->m_pNext == NULL)
return pHead;
ListNode* pReturn = ReverseLink(pHead->m_pNext);
pHead->m_pNext->m_pNext = pHead;
pHead->m_pNext = NULL;
return pReturn;
}

//反转链表的递归算法
ListNode* ReverseList2(ListNode* pHead)
{
ListNode* pReverseHead = pHead;
//考虑只有0个或1个节点
if(pHead->m_pNext == NULL || pHead->m_pNext->m_pNext == NULL)
{
return pHead;
}
pReverseHead->m_pNext = ReverseLink(pReverseHead->m_pNext);
return pReverseHead;
}

int main()
{
ListNode* pListHead = NULL;
InitList(&pListHead);

//建立两个链表
for(int i=9; i>=0; i--)
{
InsertList(pListHead, i);
}

std::cout<<"链表反转之前："<<std::endl;
PrintList(pListHead);

//ListNode* pReverseHead = ReverseList(pListHead);
ListNode* pReverseHead = ReverseList2(pListHead);

std::cout<<"链表反转之后："<<std::endl;
PrintList(pReverseHead);
system("pause");
return 0;
}