力扣（LeetCode）21. 合并两个有序链表

将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

思路：难点在于这是无头节点的链表，所以要首先找出头节点较小的链表标记为Min，另一个标记为Max，这样就对Max进行遍历，如果Max的值大于等于Min当前的值且小于Min->next的值，那么此Max的结点插入Min中且Max向后移动一位，否则Min向后移动一位

注意：要解决两个链表有一个为空或者同时为空的情况

这次跟大佬学习了递归写法，递归是真的简单其实并不是很容易理解

#include<iostream>
#include<cstdlib>
using namespace std;

typedef struct ListNode
{
    int val;
    ListNode *next;
} ListNode,*PtrToNode;

void Print(PtrToNode N)
{
    PtrToNode p = N;
    while(p!=NULL)
    {
        printf("%d ",p->val);
        p = p->next;
    }
    printf("\n");
    return;
}

PtrToNode Insert(PtrToNode N,int e)
{
    PtrToNode p = (PtrToNode)malloc(sizeof(ListNode));
    p->val = e;
    p->next = NULL;
    if(N == NULL)
    {
        N = p;
    }
    else
    {
        PtrToNode q = N;
        while(q->next != NULL)
        {
            q = q->next;
        }
        q->next = p;
    }
    return N;
}

class Solution
{
public:
    ListNode* mergeTwoLists(ListNode* l1,ListNode* l2)
    {
        ListNode *Min,*Max,*temp,*start;

        if(l1 == NULL || l2 == NULL)
            return l1 == NULL ? l2 : l1;

        if(l1->val >= l2->val)
        {
            Min = l2;
            Max = l1;
            start = l2;
        }
        else
        {
            Min = l1;
            Max = l2;
            start = l1;
        }

        while(Max!=NULL && Min->next!=NULL)
        {
            if(Max->val >=Min->val && Max->val < Min->next->val)
            {
                temp = Max;
                Max = Max->next;
                temp->next = Min->next;
                Min->next = temp;
                Min = temp;
            }
            else
            {
                Min = Min->next;
            }
        }

        if(Min->next == NULL)
            Min->next = Max;

        return start;
    }
};

//class Solution
//{
//public:
//    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2)
//    {
//
//        if(l1 == NULL || l2 == NULL)
//            return l1 == NULL ? l2 : l1;
//
//        /*使用递归的话，仍然是将起始结点值小的链表作为主链表
//        由于递归每次循环是开辟新的栈空间，所以相当于l1和l2这两个
//        指针在不断的向后移动，但是由于递归最后会返回，所以最终
//        指针仍然会返回到投结点*/
//        if(l1->val > l2->val)
//        {
//            l2->next = mergeTwoLists(l1,l2->next);
//            return l2;
//        }
//        else
//        {
//            l1->next = mergeTwoLists(l1->next,l2);
//            return l1;
//        }
//    }
//};

int main()
{
    Solution s;
    PtrToNode N,M,start;
    N = NULL;
    M = NULL;
    N = Insert(N,1);
    N = Insert(N,2);
    N = Insert(N,4);
    M = Insert(M,1);
    M = Insert(M,3);
    M = Insert(M,4);


    start = s.mergeTwoLists(N,M);

    Print(start);


    return 0;
}