LeetCode（2）合并链表、环形链表的约瑟夫问题、链表分割

一、合并链表

. - 力扣（LeetCode）

题目描述：

/**
 * 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) {
    if (list1 == NULL)
    {
        return list2;
    }
    if (list2 == NULL)
    {
        return list1;
    }//如果list1开始是空，则返回list2，反之则返回list1；当两者都为空时，先走第一个if语句那么返回list2，list2为NULL。这样写包含了所有两者中有NULL的情况

    ListNode* newhead;
    ListNode* newtail;
    newhead = newtail = (ListNode*)malloc(sizeof(ListNode));
    if (newhead == NULL)
    {
        perror("malloc fail!");
        exit(1);
    }//创建哨兵位

    ListNode* l1 = list1;
    ListNode* l2 = list2;

    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开始遍历，比较相应的val值，哪个小就把这个小的节点往哨兵位后面尾插

    if (l2)
    {
        newtail->next = l2;
    }
    if (l1)
    {
        newtail->next = l1;
    }//遍历两个链表时，会有一方先为空，另外一个不为空的的剩余的节点的val值都比新链表里面的小，并且list1、2都是升序，所以此时直接把没有插完的剩余的链表尾插到新链表的尾节点后面

    ListNode* rsl = newhead->next;
    free(newhead);
    newhead = NULL;
    return rsl;
    //动态开辟的空间要释放，但是也要依靠这个开辟的节点来返回，所以定义一个临时节点，释放完开辟的节点，将这个临时节点作为返回值。
}

---

 

二、环形链表的约瑟夫问题

环形链表的约瑟夫问题_牛客题霸_牛客网

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param n int整型 
 * @param m int整型 
 * @return int整型
 */
typedef struct ListNode ListNode;
//申请节点
ListNode* BuyNode(int x)
{
    ListNode* newnode=(ListNode*)malloc(sizeof(ListNode));
    if(newnode==NULL)
    {
        exit(1);
    }
    newnode->next=NULL;
    newnode->val=x;
    return newnode;
}
#include <stdarg.h>
int ysf(int n, int m ) {
    // write code here
    ListNode* tail;
    ListNode* head;
    tail=head=(ListNode*)malloc(sizeof(ListNode));
    if(head==NULL)
    {
        exit(1);
    }
    head->next=NULL;
    head->val=1;//设置头节点(1<=n)
    for(int i=2;i<=n;i++)
    {
        ListNode* newnode=BuyNode(i);
        tail->next=newnode;
        tail=tail->next;
    }//创建一个链表

    //创建环形链表
    tail->next=head;

    ListNode* pcur=head;
    ListNode* prev=tail;
    int count=1;

    while(pcur->next!=pcur)
    {
        if(count!=m)
        {
            pcur=pcur->next;
            prev=prev->next;
            count++;
        }
        else
        {
            prev->next=pcur->next;
            free(pcur);
            pcur=prev->next;
            count=1;
        }
    }

    return pcur->val;
}

while循环内部解释：假设n=5，m=2；最开始让pcur指向val为1的节点，让prev指向val为5的节点，设置一个计数器count，让其最开始的默认值是1；用count来记录pcur的走的步数（也就是报数为几），m为2，则先走if语句，此时pcur和prev都往后走一步，pcur指向2，prev指向1，count变为2（报数为2）要开始删除数据；则第二次循环进入else语句：开始删除数据，但是为了找到之后的链表节点，先让prev的next指针指向pcur的next指向的节点，再删除pcur（此时是2，符合题意，报数为2的删除）再让pcur为prev->next

此时prev的val为1，pcur的val为3，count重置为1（与题中当删除数据之后要从这个被删除数据的下一个数据重新开始计数）；此时循环进入if语句，count变为2（正常报数），prev的val为3，pcur的val为4；再一次循环进入else语句，开始删除数据让prev的next指向pcur的next（也就是val为5的节点），再删除pcur（val为4的节点），让pcur为prev的next；此时pcur的val为5，prev的val为3，count重置为1；

依次类推；最后只剩下val为3的节点，并且此时pcur的next指向的就是它自己，返回这个val值就是最终结果。

---

三、分割链表

. - 力扣（LeetCode）

 

/**
 * 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 NULL;
    }

    ListNode* lesshead;
    ListNode* lesstail;
    lesshead=lesstail=(ListNode*)malloc(sizeof(ListNode));

    ListNode* morehead;
    ListNode* moretail;
    morehead=moretail=(ListNode*)malloc(sizeof(ListNode));
    if(lesshead==NULL || morehead==NULL)
    {
        exit(1);
    }
    ListNode* pcur=head;
    while(pcur)
    {
        if(pcur->val<x)
        {
            lesstail->next=pcur;
            lesstail=lesstail->next;
        }
        else
        {
            moretail->next=pcur;
            moretail=moretail->next;
        }
        pcur=pcur->next;
    }

    moretail->next=NULL;
    lesstail->next=morehead->next;
    

    ListNode* rsl=lesshead->next;
    free(morehead);
    free(lesshead);
    morehead=NULL;
    lesshead=NULL;
    
    return rsl;
}

 思路：创造两个新的链表，一个存储val比x小的节点，一个存储val比x大的节点，遍历原链表根据val的大小对新的两个链表进行尾插；结束之后要把这两个链表连起来，让存储较小值的链表在前面，但是这个链表不包含哨兵位，所以要让  lesstail->next=morehead->next;  最终释放这两个动态开辟的节点，返回合并链表的头节点。