单链表——合并两个有序链表

这个题目的思路很容易就能想出来，我们可以创建一个新链表，然后用两个指针遍历两个链表，将小的节点尾插到新节点中。而循环的结束条件就是两个指针的任意一个走到空。在循环结束后，两个链表肯定其中一个走到结尾，而另一个没有走到结尾，所以我们需要在循环结束后，将没有走到结尾的链表尾插到新链表中。我们现在先实现一下这个思路。

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    ListNode*l1=list1;
    ListNode*l2=list2;

    //创建一个新链表
    ListNode*newHead;
    ListNode*newTail;
    newHead=newTail=NULL;

    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            //判断是否为空链表
            if(newHead==NULL)
            {
                newTail=newHead=l1;
            }
            else
            {
                newTail->next=l1;
                newTail=newTail->next;
            }
            l1=l1->next;
        }
        else
        {
            if(newHead==NULL)
            {
                newHead=newTail=l2;
            }
            else
            {
                newTail->next=l2;
                newTail=newTail->next;
            }
            l2=l2->next;
        }
    }

    //循环结束后l1走向空或者l2走到空
    if(l2)
    {
        newTail->next=l2;
    }
    if(l1)
    {
        newTail->next=l1;
    }
    return newHead;
}

当我们运行后会发现，当list1或list2为空链表时不成立。所以在遍历链表之前我们需要先判断list1与list2是否为空链表。若list1为空链表则直接返回list2，若list2为空链表则直接返回list1。那么我们再来实现一下。

typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
    ListNode*l1=list1;
    ListNode*l2=list2;

    //创建一个新链表
    ListNode*newHead;
    ListNode*newTail;
    newHead=newTail=NULL;

    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            //判断是否为空链表
            if(newHead==NULL)
            {
                newTail=newHead=l1;
            }
            else
            {
                newTail->next=l1;
                newTail=newTail->next;
            }
            l1=l1->next;
        }
        else
        {
            if(newHead==NULL)
            {
                newHead=newTail=l2;
            }
            else
            {
                newTail->next=l2;
                newTail=newTail->next;
            }
            l2=l2->next;
        }
    }

    //循环结束后l1走向空或者l2走到空
    if(l2)
    {
        newTail->next=l2;
    }
    if(l1)
    {
        newTail->next=l1;
    }
    return newHead;
}

当我们复盘整个代码的时候我们会发现代码中有重复的代码出现，我们需要如何去优化这个代码呢？我们首先需要搞清楚代码重复的原因，是因为在向新链表中插入节点时有空链表与非空链表两种情况。知道了重复的原因我们就能知道如何去解决这个问题。我们可以让新链表不为空链表。解决方法就是，在创建了newHead和newTail后不给他们赋值为NULL，而是动态申请一个有效且无意义的节点并赋值给newHead和newTail。那么此时链表就不为空，头尾指针都指向了一个有效的节点。

在代码执行完毕后，我们还需要将动态申请的节点手动释放掉，那么就意味着我们需要释放掉newHead这个节点，而如果我们释放掉这个节点，在后续返回头节点时就会找不到它，所以我们需要再新建一个指针指向newHead的next节点，返回时就只需要返回这个指针就可以了。

 typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) 
{
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
    ListNode*l1=list1;
    ListNode*l2=list2;

    //创建一个新链表
    ListNode*newHead;
    ListNode*newTail;
    newHead=newTail=(ListNode*)malloc(sizeof(ListNode));

    while(l1&&l2)
    {
        if(l1->val<l2->val)
        {
            newTail->next=l1;
            newTail=newTail->next;
            l1=l1->next;
        }
        else
        {
            newTail->next=l2;
            newTail=newTail->next;
            l2=l2->next;
        }
    }

    //循环结束后l1走向空或者l2走到空
    if(l2)
    {
        newTail->next=l2;
    }
    if(l1)
    {
        newTail->next=l1;
    }
    ListNode*newnode=newHead->next;
    free(newHead);
    newHead=NULL;
    return newnode;
}

这样更改过后代码就会变得更加简洁了。

大家感兴趣的可以自行解答

. - 力扣（LeetCode）