C++剑指offer——合并两个排序链表

题目描述

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

解法

解法一：创建一个新的链表
1、创建两个指针分别指向两个链表的头部
2、当这两个指针都不为空的时候，比较大小。小的那个结点的值保存下来，指针往后跳一个。然后把那个小的值接到新链表的尾部
3、循坏2直至某个链表结束
4、肯定会有其中某个链表有剩余，把剩余的那个剩下的结点全部依次接到新链表的尾部。
时间复杂度：O（N）
空间复杂度：O（N）

代码：

/*
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&&pHead2==NULL)
            return NULL;
        else if(pHead1==NULL&&pHead2!=NULL)
            return pHead2;
        else if(pHead1!=NULL&&pHead2==NULL)
            return pHead1;
        //    
        ListNode* temp1=pHead1;
        ListNode* temp2=pHead2;
        ListNode* pHead=NULL;
        ListNode* p1;
        ListNode* p2;
        int temper;
        while(temp1!=NULL&&temp2!=NULL)
        {
            if(temp1->val<=temp2->val)
            {
                temper=temp1->val;
                temp1=temp1->next;
            }
            else
            {
                temper=temp2->val;
                temp2=temp2->next;
            }
            p1=(struct ListNode*)malloc(sizeof(ListNode));
            p1->val=temper;
            if(pHead==NULL)
                pHead=p1;
            else
                p2->next=p1;
            p2=p1;
        }
        while(temp1!=NULL)
        {
            p1=(struct ListNode*)malloc(sizeof(ListNode));
            p1->val=temp1->val;
            p2->next=p1;
            p2=p1;
            temp1=temp1->next;
        }
        while(temp2!=NULL)
        {
            p1=(struct ListNode*)malloc(sizeof(ListNode));
            p1->val=temp2->val;
            p2->next=p1;
            p2=p1;
            temp2=temp2->next;
        }
        p2->next=NULL;
        return pHead;
    }
};

解法二：遍历两个链表，按大小顺序拼接
时间复杂度：O（N）
空间复杂度：O（1）
代码：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2)
    {
        ListNode* head=(struct ListNode*)malloc(sizeof(ListNode));
        head->next=NULL;
        ListNode* temp=head;
        while(pHead1!=NULL&&pHead2!=NULL)
        {
            if(pHead1->val>pHead2->val)
            {
                temp->next=pHead2;
                pHead2=pHead2->next;
            }
            else
            {
                temp->next=pHead1;
                pHead1=pHead1->next;
            }
            temp=temp->next;
        }
        if(pHead1!=NULL)
            temp->next=pHead1;
        if(pHead2!=NULL)
            temp->next=pHead2;
        return head->next;
    }
};

解法三：递归
递归很优雅的写法了，也是打开了新思路。

代码：

/*
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&&pHead2==NULL)
            return NULL;
        else if(pHead1==NULL)
            return pHead2;
        else if(pHead2==NULL)
            return pHead1;
        else if(pHead1->val<pHead2->val)
        {
            pHead1->next=Merge(pHead1->next, pHead2);
            return pHead1;
        }
        else if(pHead1->val>pHead2->val)    
        {
            pHead2->next=Merge(pHead2->next, pHead1);
            return pHead2;
        }
    }
};