剑指offer25：合并两个排序的链表

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

        链表定义如下：
        struct ListNode
        {
            int value;
            ListNode* next;
        };  

        思路：从两个链表的头结点开始，比较两个链表的头结点的值大小，值小的结点就是合并后链表的头结点，继续合并链表中剩余的节点，在两个链表中剩下的节点依然是有序的，因此合并这两个链表的步骤和前面的步骤是一样的，还是比较两个头结点的值，若其中一个链表已经全部加入到合并后的链表中而另一个链表还有剩余的节点，则将另一个链表中剩余的节点直接加入到合并后的链表中。

        以题目中给的例子为例进行分析：
    （1）定义两个指针p1和p2，分别指向两个链表的头节点，如图1所示；
    （2）链表1的头结点的值为1小于链表2的头结点的值，因此链表1的头节点是合并后链表的头节点，将p1指向链表1中的下一个节点，如图2所示；
    （3）在剩余的节点中，链表2的头节点的值小于链表1的头节点的值，因此链表2的头节点是剩余节点的头节点，把这个节点和之前已经合并好的链表的尾节点连接起来，将p2指向链表2中的下一个节点，如图3所示；
    （4）重复上面的步骤，直到其中一个链表全部加入到已经合并好的链表中，若另一个链表还有剩余的节点，则将另一个链表中剩余的节点直接加入到合并后的链表中。

具体代码如下图所示：

//带头节点的单链表非递归实现
#include <iostream>
#include <assert.h>
using namespace std;

struct ListNode
{
	int value;
	ListNode* next;
};

void Init(ListNode* pListHead)
{
	assert(pListHead != NULL);
	if(pListHead == NULL)
	{
		return ;
	}
	pListHead->next=NULL;
}

static ListNode* Buynode()
{
	ListNode *pnewnode=new ListNode();
	assert(pnewnode != NULL);
	pnewnode->next=NULL;
	return pnewnode;
}

bool InsertTail(ListNode *pListHead,int val)
{
	if(pListHead == NULL)
	{
		return false;
	}
	ListNode *pCur=pListHead;
	while(pCur->next != NULL)
	{
		pCur=pCur->next;
	}

	ListNode *pnewnode=Buynode();
	pnewnode->value=val;
	pCur->next=pnewnode;
	return true;
}


ListNode *Merge(ListNode *pListHead1,ListNode *pListHead2)
{
	if(pListHead1 == NULL)
	{
		return pListHead2;
	}
	else if(pListHead2 == NULL)
	{
		return pListHead1;
	}

	pListHead1=pListHead1->next;
	pListHead2=pListHead2->next;

	ListNode *pListHead3=new ListNode();
	ListNode *p=pListHead3;

	while(pListHead1 != NULL && pListHead2 != NULL)
	{
		if(pListHead1->value <= pListHead2->value)
		{
			p->next=pListHead1;
			pListHead1=pListHead1->next;
		}
		else
		{
			p->next=pListHead2;
			pListHead2=pListHead2->next;
		}
		p=p->next;
	}

	if(pListHead1 != NULL)
	{
		p->next=pListHead1;
	}
	else
	{
		p->next=pListHead2;
	}
		
	return pListHead3;
}



void Print(ListNode* pListHead)
{
	if(pListHead == NULL)
	{
		return;
	}
	struct ListNode* pCur=pListHead->next;
	while(pCur != NULL)
	{
		cout<<pCur->value<<" ";
		pCur=pCur->next;
	}
	cout<<endl;
}

void Clear(ListNode* pListHead)
{
	ListNode* pCur=pListHead->next;
	ListNode* pNext=pCur;
	while(pCur != NULL)
	{
		pNext=pCur->next;
		free(pCur);
		pCur=pNext;
	}
	pListHead->next=NULL;
}
 
void Destory(ListNode* pListHead)
{
	Clear(pListHead);
}

int main()
{
	ListNode pListHead1;
	ListNode pListHead2;
	Init(&pListHead1);
	Init(&pListHead2);

	int val=-1;
	for(int i=0;i<4;i++)
	{
		val=val+2;
		InsertTail(&pListHead1,val);
	}
	val=0;
	for(int i=0;i<4;i++)
	{
		val=val+2;
		InsertTail(&pListHead2,val);
	}
	Print(&pListHead1);
	Print(&pListHead2);

	ListNode *tmp;
	tmp=Merge(&pListHead1,&pListHead2);
	Print(tmp);
	
	Destory(tmp);
	return 0;
}

运行结果如下：

//不带头结点的单链表递归实现
#include <iostream>
#include <assert.h>
using namespace std;

typedef struct ListNode
{
	int value;
	ListNode* next;
}ListNode,*List;

void Init(List* pListHead)
{
	assert(pListHead != NULL);
	if(pListHead == NULL)
	{
		return ;
	}
	*pListHead=NULL;
}

static ListNode* Buynode(int val)
{
	ListNode *pnewnode=new ListNode();
	assert(pnewnode != NULL);
	pnewnode->value=val;
	pnewnode->next=NULL;
	return pnewnode;
}

bool InsertTail(List *pListHead,int val)
{
	if(pListHead == NULL)
	{
		return false;
	}

	if(*pListHead == NULL)
	{
		ListNode *pnewnode=Buynode(val);
		*pListHead=pnewnode;
		return true;
	}
	
	List pCur=*pListHead;
	while(pCur->next != NULL)
	{
		pCur=pCur->next;
	}
	List pnewnode=Buynode(val);
	pCur->next=pnewnode;
	return true;
}

ListNode *Merge(ListNode *pListHead1,ListNode *pListHead2)
{
	if(pListHead1 == NULL)
	{
		return pListHead2;
	}
	else if(pListHead2 == NULL)
	{
		return pListHead1;
	}

	ListNode *pMergedHead=NULL;
	if(pListHead1->value < pListHead2->value)
	{
		pMergedHead=pListHead1;
		pMergedHead->next=Merge(pListHead1->next,pListHead2);
	}
	else
	{
		pMergedHead=pListHead2;
		pMergedHead->next=Merge(pListHead1,pListHead2->next);
	}
	return pMergedHead;
}

void Print(ListNode* pListHead)
{
	if(pListHead == NULL)
	{
		return;
	}
	ListNode* pCur=pListHead;
	while(pCur != NULL)
	{
		printf("%d  ",pCur->value);
		pCur=pCur->next;
	}
	printf("\n");
}

void Clear(ListNode* pListHead)
{
	struct ListNode* pCur=pListHead->next;
	struct ListNode* pNext=pCur;
	while(pCur != NULL)
	{
		pNext=pCur->next;
		free(pCur);
		pCur=pNext;
	}
	pListHead->next=NULL;
}
 
void Destory(ListNode* pListHead)
{
	Clear(pListHead);
}

int main()
{
	List pListHead1;
	List pListHead2;
	Init(&pListHead1);
	Init(&pListHead2);
	int val=-1;
	for(int i=0;i<4;i++)
	{
		val=val+2;
		InsertTail(&pListHead1,val);
	}
	val=0;
	for(int i=0;i<4;i++)
	{
		val=val+2;
		InsertTail(&pListHead2,val);
	}
	Print(pListHead1);
	Print(pListHead2);

	List tmp;
	tmp=Merge(pListHead1,pListHead2);
	Print(tmp);
	return 0;
}

运行结果如下：