合并两个排序的链表

题目：输入两个递增排序的链表，合并这两个链表并使新链表中的结点仍然是按照递增排序的。

方法一:递归 : 要注意递归结束的条件及代码的鲁棒性

方法二:非递归。需要较多的指针

#include<iostream>
#include<stdio.h>
#include<tchar.h>

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

ListNode* CreateListNode(int value)
{
    ListNode* pNode = new ListNode();
    pNode->m_nValue = value;
    pNode->m_pNext = NULL;
    
    return pNode;    
}

void PrintList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        printf("%d	",pNode->m_nValue);
        pNode = pNode->m_pNext;
    }
    printf("
");
}

void DestroyList(ListNode* pHead)
{
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        pHead = pHead->m_pNext;
        delete pNode;
        pNode = pHead;
    }
}

void ConnectListNodes(ListNode* pCurrent, ListNode* pNext)
{
    if(pCurrent == NULL)
    {
        printf("Error to connect two nodes.
");
        exit(1);
    }
    
    pCurrent->m_pNext = pNext;
}

//方法1 递归  要注意代码的鲁棒性 
ListNode* Merge1(ListNode* pHead1, ListNode* pHead2)
{
    if(pHead1 == NULL)
        return pHead2;
    else if(pHead2 == NULL)
        return pHead1;
    
    ListNode* pMergedHead = NULL;
    
    if(pHead1->m_nValue < pHead2->m_nValue)
    {
        pMergedHead = pHead1;
        pMergedHead->m_pNext = Merge1(pHead1->m_pNext, pHead2);
    }
    else
    {
        pMergedHead = pHead2;
        pMergedHead->m_pNext = Merge1(pHead1, pHead2->m_pNext);
    }
    
    return pMergedHead;
}

//方法2: 非递归  比递归麻烦太多，定义的指针也多了一些。不过容易理解 
ListNode* Merge2(ListNode* pHead1, ListNode* pHead2)
{
    if(pHead1 == NULL)
        return pHead2;
    if(pHead2 == NULL)
        return pHead1;

    ListNode* pNode1 = pHead1;
    ListNode* pNode2 = pHead2;
    ListNode* pMergedHead = NULL; //合并后的链表的头结点 
    ListNode* pCurLastNode = NULL;

    if(pNode1->m_nValue < pNode2->m_nValue)
    {
        pMergedHead = pHead1;
        pNode1 = pNode1->m_pNext;
        pCurLastNode = pMergedHead;
    }
    else
    {
        pMergedHead = pHead2;
        pNode2 = pNode2->m_pNext;
        pCurLastNode = pMergedHead;
    }

    while(pNode1 !=NULL && pNode2 != NULL)
    {
        if(pNode1->m_nValue < pNode2->m_nValue)
        {
            pCurLastNode->m_pNext = pNode1;
            pCurLastNode = pNode1;
            pNode1 = pNode1->m_pNext;
        }
        else
        {
            pCurLastNode->m_pNext = pNode2;
            pCurLastNode = pNode2;
            pNode2 = pNode2->m_pNext; 
        }

        if(pNode1 == NULL)
            pCurLastNode->m_pNext = pNode2;
        if(pNode2 == NULL)
            pCurLastNode->m_pNext = pNode1;
    }
    return pMergedHead;
}

//list1: 1->3->5
//list2: 2->4->6

int main()
{
    ListNode* pNode1 = CreateListNode(1);
    ListNode* pNode3 = CreateListNode(3);
    ListNode* pNode5 = CreateListNode(5);
    
    ConnectListNodes(pNode1, pNode3);
    ConnectListNodes(pNode3, pNode5);
    
    ListNode* pNode2 = CreateListNode(2);
    ListNode* pNode4 = CreateListNode(4);
    ListNode* pNode6 = CreateListNode(6);
    
    ConnectListNodes(pNode2, pNode4);
    ConnectListNodes(pNode4, pNode6);
    
    printf("The first list is:
");
    PrintList(pNode1);
    
    printf("The second list is:
");
    PrintList(pNode2);
    
    printf("The merged list is:
");
    
    //由于函数是会改变链表，不能同时运行。将true改变为false即可测试方法二 
    if(true)
    {
        printf("Solution1
");
        ListNode* pMergedHead = Merge1(pNode1, pNode2);
        PrintList(pMergedHead);
        DestroyList(pMergedHead);
    }
    else
    {
        printf("Solution2
");
        ListNode* pMergedHead = Merge2(pNode1, pNode2);
        PrintList(pMergedHead);
        DestroyList(pMergedHead);
    }
    
}