剑指offer——面试题17：合并两个排序的链表（非递归方法和递归方法）

      题目：输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

      分析：一开始拿到这一题，我没想到使用递归的方法，自己写了一个非递归的，不得不说，和《剑指offer》书上相比，确实不够简洁。

我的代码：

/* 
struct ListNode { 
    int val; 
    struct ListNode *next; 
    ListNode(int x) : 
            val(x), next(NULL) { 
    } 
};*/  
class Solution {  
public:  
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)  
    {  
           
        if(pHead1==NULL)  
            return pHead2;  
        if(pHead2==NULL)  
            return pHead1;  
          
        ListNode* MergeHead=NULL;  //合并后的头指针  
        ListNode* MergeCurrent=NULL; //指向合并后链表的当前指针  
          
        while(pHead1!=NULL && pHead2!=NULL){  
              
            if(pHead1->val<pHead2->val){   
                if(MergeHead==NULL){    
                    //第一个链表第一个节点值小与第二个链表第一个节点值，以第一个链表的第一个节点作为合并后链表的头指针  
                    MergeHead=pHead1;  
                    MergeCurrent=pHead1;  
                }  
                else{  
                    //第一个链表结点值小于第二个链表结点值，将第一个链表结点连接在合并后的链表的后面  
                    MergeCurrent->next=pHead1;  
                    MergeCurrent=MergeCurrent->next;  
                }  
                pHead1=pHead1->next;  
            }  
            else{  
                if(MergeHead==NULL){  
                    //第二个链表第一个节点值小与第一个链表第一个节点值，以第一个链表的第一个节点作为合并后链表的头指针  
                    MergeHead=pHead2;  
                    MergeCurrent=pHead2;  
                }  
                else{  
                    MergeCurrent->next=pHead2;  
                    MergeCurrent=MergeCurrent->next;  
                }  
                pHead2=pHead2->next;  
                  
            }//else  
                  
        }//while  
          
        if(pHead1==NULL){  
            //如果第一个链表已经合并完，将第二个链表直接连接在合并链表的后面  
            MergeCurrent->next=pHead2;  
        }  
       if(pHead2==NULL){  
           MergeCurrent->next=pHead1;  
       }  
          
        return MergeHead;  
    }  
};  

《剑指offer》代码：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
/*

class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        if(pHead1 == NULL)
            return pHead2;
        if(pHead2 == NULL)
            return pHead1;
        ListNode* pNewNode = NULL;
        if(pHead1->val >= pHead2->val)
        {
            pNewNode = pHead2;
            pNewNode->next = Merge(pHead1,pHead2->next);
        }
        else
        {
            pNewNode = pHead1;
            pNewNode->next = Merge(pHead1->next,pHead2);
        }
        return pNewNode;
    }
};

      分析：这一题可能会出现两个错误：一、写代码之前没有对合并的过程想清楚，最终合并出来的链表，要么中间断开了，要么没有做到递增排序；二是代码的鲁棒性方面存在问题，程序一旦有特殊的输入（比如输入空链表），程序就会崩溃。

      当我们得到两个链表中值较小的头结点，并把它链接到已经合并的链表之后，两个链表剩余的结点依然是排序的，因此，合并的步骤和之前的步骤是一样的，这是典型的递归！我们可以定义递归函数来完成这一操作。

      对于鲁棒性的问题。每当代码试图访问空指针指向的内存时，程序就会崩溃，因此我们需要对空链表进行单独处理。也就有了这样的代码：

if(pHead1 == NULL)
            return pHead2;
if(pHead2 == NULL)
            return pHead1;

注意：这两句是在递归函数中的，而不是单独存在的。如果不适用递归方法，这两句要写在循环里，不断进行判断。