什么是对比分析法

一.移除数组元素

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val) 
{
    ListNode* pcur=head;
    //创建一个新链表
    ListNode* newTail=NULL;//指向头的指针
    ListNode* newHead=NULL;//指向尾的指针
    while(pcur)//当pcur不为NULL的时候，进入循环
    {
        if(val!=pcur->val)//val在链表里没有此数据，进入if语句
         {
            if(newTail==NULL)//刚开始新链表为NULL时
            {
                newHead=newTail=pcur;//头指针和尾指针都指向刚开始的头结点
            }
            else //新链表已经有数据了，执行尾插操作
            {
                newTail->next=pcur;//newTail的next指针指向pcur节点
                newTail=newTail->next;//将newTail往后移动一个节点
            }
         }
         pcur=pcur->next;//每经过一次的循环，pcur就往后移动一个节点
    }
    if(newTail)//这里有一个if语句主要是为了避免传参过来的head为NULL的情况
    //如果head为NULL，那么上面的while循环就不会进入，newTail还是为NULL
    newTail->next=NULL;//把新链表的尾节点的next指针置为NULL
    //如果这里不置为NULL的话，假设我的head链表是1,2,6,4,5,6.要去除6的话。那么这里的newTail->next就还是指向的是6所在的这个节点
    return newHead;//返回我的新链表
}

下面是三种测试结果，分别对应三种情况： 

二. 反转链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {
    //判断head是否为NULL
    if(head==NULL)
    {
        return head;//如果为NULL，则返回NULL，程序不再往下执行
    }
    //我们创建三个指针，一直指向NULL，一个指向头结点，一个指向第二个节点
    ListNode* n1=NULL;
    ListNode* n2=head;
    ListNode* n3=n2->next;
    while(n2)//当n2为NULL时跳出循环
    {
    n2->next=n1;//n2->next原本指向的是第二个节点，这里直接给它指向n1
    n1=n2;//把n1指向的位置移动到n2的位置
    n2=n3;//把n2移动到n3的位置，等到n3走到NULL的时候，赋值给n2，此时也就跳出循环
    if(n3)
        n3=n3->next;//n3一直走到尾节点的后面：NULL
    }
    return n1;//n1的位置此时就在我们新的头结点的位置
}

 这个就是需要单独判断一下传参过去的链表为NULL的情况。然后通过三个指针的移动来实现链表的反转。

 三.链表的中间节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
    ListNode* slow=head;//慢指针
    ListNode* fast=head;//快指针
    while(fast&&fast->next)//这两个条件不能反过来，因为fast是有可能为NULL的，如果反过来了，此时就会出现空指针解引用的情况。
    {
        slow=slow->next;//一次往后走一个节点
        fast=fast->next->next;//一次往后走两个节点
    }
    return slow;//此时的slow就是中间节点，直接返回就行了
}

四.合并两个有序链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
 typedef struct ListNode ListNode;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2)
 {
    //如果两个链表有一个为NULL，则直接返回另一个链表
    if(list1==NULL)
    {
        return list2;
    }
    if(list2==NULL)
    {
        return list1;
    }
    ListNode* l1=list1;
    ListNode* l2=list2;
    //定义一个新的链表，有新头和新尾
    ListNode* newHead,*newTail;
    //直接开辟一块动态内存的空间，当做我们的头结点，也叫做哨兵位
    newHead=newTail=(ListNode*)malloc(sizeof(ListNode));
    while(l1&&l2)//当两个链表为其中一个完全遍历完，为NULL的时候出循环
    {
        if(l1->val < l2->val)
        {
            //l1的val比l2的小，把l1拿下来尾插
            newTail->next=l1;
            newTail=l1;
            l1=l1->next;
        }
        else
        {
            //把l2拿下来尾插
            newTail->next=l2;
            newTail=l2;
            l2=l2->next;
        }
    }
    //出了循环，不一定全部的节点都接在了新链表的后面
    if(l1==NULL)
    {
        newTail->next=l2;//把l2后面的节点也都给接过来
    }
    if(l2==NULL)
    {
        newTail->next=l1;//把l1后面的节点也都给接过来
    }
    ListNode* ret=newHead->next;//先把头结点的下一个节点给存起来，避免后面释放空间导致丢失
    free(newHead);
    newHead=NULL;
    return ret;//直接返回我们有效的节点
}

五.环形链表的约瑟夫问题

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param n int整型 
 * @param m int整型 
 * @return int整型
 */
 typedef struct ListNode ListNode;
 //创建节点
 ListNode* buyNode(int x)
 {
    ListNode* node=(ListNode*)malloc(sizeof(ListNode));
    if(node==NULL)
    {
        exit(1);
    }
    node->val=x;
    node->next=NULL;
    return node;
 }
 //创建循环链表
 ListNode* nodeCircle(int n)
 {
    ListNode* phead=buyNode(1);//先创建第一个节点
    ListNode* ptail=phead;
    for(int i=2;i<=n;i++)
    {
        ptail->next=buyNode(i);//一个一个的创建节点
        ptail=ptail->next;//指针依次往后走，直到尾节点
    }
    ptail->next=phead;//把最后一个节点的next指针指向头结点，就构成了循环链表
    return ptail;//返回的是头结点的前一个节点
 }
int ysf(int n, int m )
{
    ListNode* prev=nodeCircle(n);//这个指针指向的就是头结点的前一个节点
    ListNode* pcur=prev->next;//pcur指向的是头结点
    int count=1;//用来计数
    while(pcur->next!=pcur)//链表只有一个节点了，就跳出循环了
    {
        if(count==m)
        {
            prev->next=pcur->next;//直接跳过要删除的链表，指向下下一个链表
            free(pcur);
            pcur=prev->next;//pcur再往后移动
            count=1;//这里重新计数
        }
        else
        {
            //此时不需要删除节点
            prev=pcur;
            pcur=pcur->next;
            count++;
        }
    }
    return pcur->val;//剩下的这个节点里的值就是我们需要的值
}

六.分割链表

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x)
{
    if(head==NULL)
    {
        return head;
    }
    //创建两个带头链表：大链表和小链表
    ListNode* lessHead,*lessTail;
    ListNode* greatHead,*greatTail;
    lessHead=lessTail=(ListNode*)malloc(sizeof(ListNode));
    greatHead=greatTail=(ListNode*)malloc(sizeof(ListNode));

    ListNode* pcur=head;
    while(pcur)//原链表走到NULL时跳出循环
    {
        if(pcur->val<x)//小于x就把节点尾插到小链表中
        {
            lessTail->next=pcur;
            lessTail=lessTail->next;//尾插完就把链表的尾节点，跳到下一个节点
        }
        else//反之，尾插到大链表中
        {
            greatTail->next=pcur;
            greatTail=greatTail->next;
        }
        pcur=pcur->next;//进行一次循环，pcur也要往后走
    }
    greatTail->next=NULL;//如果不把大链表的尾节点的next指针置为NULL，这就是个死循环
    lessTail->next=greatHead->next;//把小链表的尾节点插入到大链表的第一个有效节点
    return lessHead->next;//返回的也必须是有效节点
}

做完这些题关于链表的知识我们基本上也有了一定的认识。感谢大家的观看，如有错误，请大家多多指出。