单链表的应用（1）

移除链表元素

给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

思路：（1）创建三个结构体指针，分别代表一条新链表的头newhead，一条新链表的尾newtail，还有一个用于循环旧链表的pcur
（2）循环旧链表，当pcur的val不等于函数参数中的val时：1.当新链表为空时，将新链表的newhead和newtail赋值为pcur 2.当新链表不为空时，newtail的next指向pcur，newtail赋值为newtial的next；
（3）运行完一个结点pcur赋值为pcur的next
（4）当运行结束时，代表旧链表运行完毕，当最后一个结点等于val时，newtail的值不会是空，而是旧链表最后一个结点的值，因此我们需要进行判断，当newtail不为空时，需要将newtail置空，最后返回newhead即可

struct ListNode* removeElements(struct ListNode* head, int val)
{
    struct ListNode* newhead=NULL;
    struct ListNode* newtail=NULL;
    struct ListNode* pcur=head;
    while(pcur)
    {
        if(pcur->val != val)
        {
            if(newhead == NULL)
            {
                newhead=newtail=pcur;
            }
            else
            {
                newtail->next=pcur;
                newtail=newtail->next;
            }
        }
        pcur=pcur->next;
    }
    if(newtail)
    {
        newtail->next=NULL;
    }
    return newhead;
}

反转链表

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

思路：（1）若链表为空，则直接返回空
（2）若不为空，创建三个结构体指针分别为n1,n2,n3，将n1赋值为NULL，n2赋值为head，n3赋值为head->next
（3）以n2为循环条件进行遍历，每次运行都将n2的next赋值为n1，n1赋值为n2，n2赋值为n3，若n3不为空则n3赋值为n3的next（下图为第一次和第二次循环图）
（4）又因为n2和n3最后的位置都为NULL，所以最后返回n1即可。

struct ListNode* reverseList(struct ListNode* head) 
{
    if(head==NULL)
    {
        return NULL;
    }
    struct ListNode* n1=NULL;
    struct ListNode* n2=head;
    struct ListNode* n3=head->next;
    while(n2)
    {
        n2->next=n1;
        n1=n2;
        n2=n3;
        if(n3)
        {
            n3=n3->next;
        }
    }
    return n1;
}

合并两个有序链表

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

思路：（1）判断传入的参数list1、list2是否为空，为空则返回另一个
（2）创建四个结构体指针，newhead代表新链表的头，newtail代表新链表的尾，pcur1和pcur2分别用来遍历list1和list2
（3）若pcur1和pcur2都不为空则进入循环，当pcur1的val大于pcur2的val，判断newhead是否为空，为空则将newhead和newtail赋值为pcur1，不为空则进行新链表结点的插入，即将newtail的next赋值为pcur1，newtail赋值为newtail的next；pcur1小于等于pcur2时同理，只需将pcur1改为pcur2即可
（4）当循环结束，判断pcur1与pcur2是否为空，某个不为空时，将newtail的next赋值为不为空的pcur，最后返回newhead即可

• 不带头单向不循环链表

//不带头单向不循环链表
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    struct ListNode* newhead=NULL;
    struct ListNode* newtail=NULL;
    struct ListNode* pcur1=list1;
    struct ListNode* pcur2=list2;
    while(pcur1 && pcur2)
    {
        if((pcur1->val) < (pcur2->val))
        {
            if(newhead == NULL)
            {
                newhead=newtail=pcur1;
            }
            else
            {
                newtail->next=pcur1;
                newtail=newtail->next;
            }
            pcur1=pcur1->next;
        }
        else
        {
            if(newhead == NULL)
            {
                newhead=newtail=pcur2;
            }
            else
            {
                newtail->next=pcur2;
                newtail=newtail->next;
            }
            pcur2=pcur2->next;
        }
    }
    if(pcur1 != NULL)
    {
        newtail->next=pcur1;
    }    
    if(pcur2 != NULL)
    {
        newtail->next=pcur2;
    }
    return newhead;
}

• 带头单向不循环链表
  思路：（1）newhead和newtail的初始值不再是NULL，而是一个没有val值的结点，相当于是一个哨兵位。因此就不再需要判断newhead是否为空。
  （2）最后需要将malloc的newhead指针释放，需要创捷一个新结构体指针rehead赋值为newhead的next，便可进行newhead的释放，最后返回rehead即可

struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
{
    if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }
    struct ListNode* newhead=(struct ListNode*)malloc(sizeof(struct ListNode));
    struct ListNode* newtail=newhead;
    struct ListNode* pcur1=list1;
    struct ListNode* pcur2=list2;
    while(pcur1 && pcur2)
    {
        if((pcur1->val) < (pcur2->val))
        {
            newtail->next=pcur1;
            newtail=newtail->next;
            pcur1=pcur1->next;
        }
        else
        {
            newtail->next=pcur2;
            newtail=newtail->next;
            pcur2=pcur2->next;
        }
    }
    if(pcur1 != NULL)
    {
        newtail->next=pcur1;
    }    
    if(pcur2 != NULL)
    {
        newtail->next=pcur2;
    }
    struct ListNode* rehead=newhead->next;
    free(newhead);
    newhead=NULL;
    return rehead;
}

链表的中间结点

给你单链表的头结点 head ，请你找出并返回链表的中间结点。
如果有两个中间结点，则返回第二个中间结点。

思路：（1）运用快慢指针，创建两个结构体指针，分别为slow和fast，slow每次走一个结点，fast每次走两个结点（如下图）
（2）返回slow指针即可

struct ListNode* middleNode(struct ListNode* head) 
{
    struct ListNode* fast=head;
    struct ListNode* slow=head;
    while(fast && fast->next)
    {
        slow=slow->next;
        fast=fast->next->next;
    }
    return slow;
}