【剑指offer】4.合并两个排序的链表

总目录：

算法之旅导航目录

 

1.问题描述
输入两个递增的链表，单个链表的长度为n(两链表长度不一定相等)，合并这两个链表并使新链表中的节点仍然是递增排序的。
数据范围： 0≤n≤1000，−1000≤节点值≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)
如输入{1,3,5},{2,4,6}时，合并后的链表为{1,2,3,4,5,6}，所以对应的输出为{1,2,3,4,5,6}；
或输入{-1,2,4},{1,3,4}时，合并后的链表为{-1,1,2,3,4,4}，所以对应的输出为{-1,1,2,3,4,4}。

2.问题分析
两链表长度不一定相等，注意当一个已经为空另一个不为空时的处理方法；
可采取的方法：
1暴力迭代，逐个识别大小添加到新链表中，注意维护2个输入链表的指针；
2栈，先压栈再弹栈；
3递归,调用递归时注意输入元素的选择，颇有田忌赛马的感觉；

3.代码实例

暴力迭代

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
  public:
    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {

        ListNode* newHead = new ListNode(1);//创建头节点
        ListNode* curNode = newHead;

        while (pHead1 != NULL && pHead2 != NULL) {
            if (pHead1->val >= pHead2->val) {
                curNode->next = pHead2;
                pHead2 = pHead2->next;
            } else {
                curNode->next = pHead1;
                pHead1 = pHead1->next;
            }
            curNode = curNode->next;
        }

        if (pHead1 != NULL) {
            curNode->next = pHead1;
        }
        if (pHead2 != NULL) {
            curNode->next = pHead2;
        }

        curNode = newHead->next; //取有有效数据的第一个节点
        delete newHead;//释放无数据的头节点
        return curNode;
    }
};

栈，虽然空间复杂度>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* newHead = NULL;
        ListNode* tempP = NULL;
        stack<ListNode*> sp;

        //压栈,有序化
        while (pHead1 != NULL || pHead2 != NULL) {
            if (pHead1 == NULL) {
                sp.push(pHead2);
                pHead2 = pHead2->next;
                continue;
            }
            if (pHead2 == NULL) {
                sp.push(pHead1);
                pHead1 = pHead1->next;
                continue;
            }

            //比较二者大小
            if (pHead1->val >= pHead2->val) {
                sp.push(pHead2);
                pHead2 = pHead2->next;
            } else {
                sp.push(pHead1);
                pHead1 = pHead1->next;
            }
        }

        //弹栈
        while (!sp.empty()) {
            tempP = sp.top();
            sp.pop();

            tempP->next = newHead;
            newHead = tempP;
        }


        return newHead;
    }
};

 递归，最精妙

/*
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 pHead1 == NULL ? pHead2 : pHead1;
        }

        //调用递归，两个元素依次对比
        if(pHead1->val>pHead2->val)
        {
            pHead2->next=Merge(pHead1,pHead2->next);
            return pHead2;
        }
        else
        {
            pHead1->next=Merge(pHead1->next,pHead2);
            return pHead1;
        }
    }
};