【剑指offer】第二十四题(反转链表) 和 第二十五题(合并两个有序链表)

第二十四题：反转链表

题目：定义一个函数，输入一个链表的头结点，反转该链表并输出反转 后链表的头结点。链表定义结点如下：

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

解题程序如下；
#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;

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

// 给链表创建结点
ListNode *CreateListNode(int val)
{
ListNode * pNew = (ListNode*)malloc(sizeof(ListNode));
if(pNew == NULL)
{
printf("pNew malloc failed!\n");
return NULL;
}
pNew->m_pNext = NULL;
pNew->m_nVale = val;
return pNew;
}

// 连接链表

void ConnectListNode(ListNode* pNode1,ListNode* pNode2)
{
if(pNode1 == NULL)
{
printf("pNode1 is NULL\n");
return;
}

pNode1->m_pNext = pNode2;
}

// 打印链表

void printListNode(ListNode *pNode)
{
while(pNode)
{
printf("%d\t",pNode->m_nVale);
pNode = pNode->m_pNext;
}
printf("\n");
}

// 销毁链表

void DestroyListNode(ListNode* pHead)
{
while(pHead)
{
ListNode *temp = pHead;
pHead = pHead->m_pNext;

free(temp);
temp = NULL;
}
}

ListNode* ReverseList(ListNode* pHead)
{
ListNode* pReversedHead = NULL;
ListNode* pNode = pHead;
ListNode* pPrev = NULL;

while(pNode)
{
ListNode* pNext = pNode->m_pNext;
if(NULL == pNext)
pReversedHead = pNode;

pNode->m_pNext = pPrev;
pPrev = pNode;
pNode = pNext;
}

return pReversedHead;
}

// 测试用例

void test()
{
// 创建链表的结点
ListNode *pNode1 = CreateListNode(1);
ListNode *pNode2 = CreateListNode(2);
ListNode *pNode3 = CreateListNode(3);
ListNode *pNode4 = CreateListNode(4);
ListNode *pNode5 = CreateListNode(5);
ListNode *pNode6 = CreateListNode(6);

// 连接链表结点
ConnectListNode(pNode1,pNode2);
ConnectListNode(pNode2,pNode3);
ConnectListNode(pNode3,pNode4);
ConnectListNode(pNode4,pNode5);
ConnectListNode(pNode5,pNode6);

// 打印链表结点
printListNode(pNode1);

// 反转链表
ListNode* pReversepHead = ReverseList(pNode1);

// 打印链表结点
printListNode(pReversepHead);

// 销毁链表
DestroyListNode(pReversepHead);

}

int main(void)
{
test();
return 0;
}
第二十五题：合并两个有序链表

题目：

输入两个递增排序的链表，合并这两个链表并使新链表中的 结点仍然是递增排序的。例如，下图的链表 1 和链表 2，则合并之后的升序链表如图3。链表结点定义如下所示：

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



解题程序如下：
#include<stdio.h>
#include<stdlib.h>
using namespace std;

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

// 给链表创建结点
ListNode *CreateListNode(int val)
{
ListNode * pNew = (ListNode*)malloc(sizeof(ListNode));
if(pNew == NULL)
{
printf("pNew malloc failed!\n");
return NULL;
}
pNew->m_pNext = NULL;
pNew->m_nVale = val;
return pNew;
}

// 连接链表

void ConnectListNode(ListNode* pNode1,ListNode* pNode2)
{
if(pNode1 == NULL)
{
printf("pNode1 is NULL\n");
return;
}

pNode1->m_pNext = pNode2;
}

// 打印链表

void printListNode(ListNode *pNode)
{
while(pNode)
{
printf("%d\t",pNode->m_nVale);
pNode = pNode->m_pNext;
}
printf("\n");
}

// 销毁链表

void DestroyListNode(ListNode* pHead)
{
while(pHead)
{
ListNode *temp = pHead;
pHead = pHead->m_pNext;

free(temp);
temp = NULL;
}
}

ListNode* Merge(ListNode* pHead1,ListNode* pHead2)
{
if(pHead1 == NULL)
return pHead2;
else if(pHead2 == NULL)
return pHead1;

ListNode* pMergedHead = NULL;

if(pHead1->m_nVale < pHead2->m_nVale)
{
pMergedHead = pHead1;
pMergedHead->m_pNext = Merge(pHead1->m_pNext,pHead2);
}
else
{
pMergedHead = pHead2;
pMergedHead->m_pNext = Merge(pHead1,pHead2->m_pNext);
}

return pMergedHead;
}

// 测试用例
void test()
{
// 创建链表的结点
ListNode *pNode1 = CreateListNode(1);
ListNode *pNode3 = CreateListNode(3);
ListNode *pNode5 = CreateListNode(5);
ListNode *pNode7 = CreateListNode(7);

// 连接链表结点
ConnectListNode(pNode1,pNode3);
ConnectListNode(pNode3,pNode5);
ConnectListNode(pNode5,pNode7);

ListNode *pNode2 = CreateListNode(2);
ListNode *pNode4 = CreateListNode(4);
ListNode *pNode6 = CreateListNode(6);
ListNode *pNode8 = CreateListNode(8);

// 连接链表结点
ConnectListNode(pNode2,pNode4);
ConnectListNode(pNode4,pNode6);
ConnectListNode(pNode6,pNode8);

ListNode* pHead1 = pNode1;
ListNode* pHead2 = pNode2;

// 打印链表结点
printListNode(pHead1);
printListNode(pHead2);

ListNode* pMergedHead = Merge(pHead1,pHead2);
if( NULL == pMergedHead )
return;
printListNode(pMergedHead);

// 销毁链表
DestroyListNode(pMergedHead);

}

int main(void)
{
test();

return 0;
}