《算法之美》の链表问题の单向链表的反转

题目：输入一个链表的头节点，反转这个链表，并返回反转后链表的头节点，链表定义如下：
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;
}