剑指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* head = new ListNode(NULL);
        ListNode* pre = head;
        pre->next = phead1;
        while(pre->next != NULL && phead2 != NULL){ //以pre为基准将phead2填入pre中
            if(pre->next->val > phead2->val){
                ListNode* arg = new ListNode(phead2->val); //用来存储当前较小结点
                ListNode* temp = pre->next; //常规链表插入操作
                pre->next = arg;
                pre->next->next = temp;
                phead2 = phead2->next;
            }
            pre = pre->next; //将基准链表向后移动
        }
        if(phead2 != NULL) //如果phead2尚未插入完毕，则将其全部填入pre后
            pre->next = phead2;
        head = head->next;
        return head;
    }
};

代码（递归版本）：

public ListNode Merge(ListNode list1,ListNode list2) {
       if(list1 == null){
           return list2;
       }
       if(list2 == null){
           return list1;
       }
       if(list1.val <= list2.val){
           list1.next = Merge(list1.next, list2);
           return list1;
       }else{
           list2.next = Merge(list1, list2.next);
           return list2;
       }       
   }

 我的笔记：迭代版本的实现以一条链表为基准，将另一条链表插入其中。

注意：1. 在对链表进行操作时，例如：temp = pre->next ;，是将 pre->next 的地址赋值给temp,而 *temp = *pre 的话是将*pre完全复制给*temp；区别在于，前者在对temp进行操作时，同时也会更改pre->next的值，而后者在对*temp操作时，*pre是不会受到影响的。是地址与指针的区别。