剑指Offer系列---(18)反转链表(递归与非递归实现)

1.题目描述：
定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的结点。链表结点定义如下：
struct ListNode
{
   int       m_nKey;
   ListNode* m_pNext;
};
2.分析：
1）定义3个指针，分别指向当前遍历到的结点、它的前一个结点以及后一个结点。
2）考虑三种情况：a.输入的链表头指针是NULL;b.输入的链表只有一个结点;c.输入的链表有多个结点。
3）考虑递归实现方式。

3.源代码：

//  Copyright (c) 2015年 skewrain. All rights reserved.

#include <iostream>
#include <stdio.h>
#include <stack>
using namespace std;

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

ListNode* CreateLink(int a[],int k)
{
    ListNode *Head = NULL,*q = NULL;
    for (int i=0; i<k; i++)
    {
        ListNode *pNew = new ListNode();
        pNew->m_nValue = a[i];
        pNew->m_pNext = NULL;
        
        if(Head==NULL)
        {
            Head = pNew;
            q = pNew;
        }
        else
        {
            q->m_pNext = pNew;
            q = pNew;
        }
    }
    return Head;
}

//从头到尾打印列表
void printLink(ListNode *pHead)
{
    cout<<"链表内容为:";
    ListNode *p = pHead;
    while (p) {
        cout<<p->m_nValue<<" ";
        p=p->m_pNext;
    }
    cout<<endl;
}

ListNode* ReverseList1(ListNode* pHead)
{
    ListNode* pReversedHead = NULL;
    ListNode* pNode = pHead;
    ListNode* pPrev = NULL;
    while(pNode != NULL)
    {
        ListNode* pNext = pNode->m_pNext;
        
        if(pNext == NULL)
            pReversedHead = pNode;
        pNode->m_pNext = pPrev;
        pPrev = pNode;
        pNode = pNext;
    }
    return pReversedHead;
}

//采用递归方式完成
ListNode* ReverseList2(ListNode *head)
{
    //如果链表为空或者链表中只有一个元素
    if(head == NULL || head->m_pNext == NULL)
        return head;
    else
    {
        ListNode* newHead = ReverseList2(head->m_pNext);//先反转后面的链表
        head->m_pNext->m_pNext = head;//再将当前结点设置为后面结点的后续结点
        head->m_pNext = NULL;
        return newHead;
    }
}

//========测试用例========
//1.输入的链表的头指针为NULL
void Test1()
{
    cout<<"测试用例1"<<endl;
    ListNode *ptr = NULL;
    cout<<"反转之前的";
    printLink(ptr);
    ListNode *p = ReverseList1(ptr);
    cout<<"反转之后的";
    printLink(p);
}
//2.输入的链表中只有一个结点
void Test2()
{
    cout<<"测试用例2"<<endl;
    int a[]={1};
    ListNode *ptr = CreateLink(a,1);
    cout<<"反转之前的";
    printLink(ptr);
    ListNode *p = ReverseList1(ptr);
    cout<<"反转之后的";
    printLink(p);
}
//3.输入的链表中有多个结点
void Test3()
{
    cout<<"测试用例3"<<endl;
    int a[]={1,2,3,4,5};
    ListNode *ptr = CreateLink(a,5);
    cout<<"反转之前的";
    printLink(ptr);
    ListNode *p = ReverseList1(ptr);
    cout<<"反转之后的";
    printLink(p);
}
//4.递归方式
void Test4()
{
    cout<<"测试用例4"<<endl;
    int a[]={1,2,3,4,5};
    ListNode *ptr = CreateLink(a,5);
    cout<<"反转之前的";
    printLink(ptr);
    ListNode *p = ReverseList2(ptr);
    cout<<"反转之后的";
    printLink(p);
}

int main(int argc,char *argv[]){

    Test1();
    cout<<endl;
    Test2();
    cout<<endl;
    Test3();
    cout<<endl;
    Test4();

    return 0;
}