单链表经典算法

前言：基于单链表的基本理解（具体详见上一篇博客），完成几道有关单链表经典算法题

1，单链表相关经典算法OJ题1：移除链表元素 

203. 移除链表元素 - 力扣（LeetCode）

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

思路一

遍历原链表，将值为val节点释放掉

思路二

找值不为val的节点，尾插到新节点

 typedef struct ListNode ListNode;
struct ListNode* removeElements(struct ListNode* head, int val)
 {
    //创建一空链表
    ListNode* newHead,*newTail;
    newHead = newTail = NULL;
    //遍历原链表
    ListNode* pcur = head;
    while(pcur)
    {
        //找值不为val的节点，尾插到新链表中
        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;
}

考虑空链表情况及要将最后节点next指向NULL 

2，单链表相关经典算法OJ题2：反转链表 

206. 反转链表 - 力扣（LeetCode）

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

思路一

创建新链表，将原链表中的节点拿过来头插

思路二

创建三个指针，完成原链表的翻转

让n2的next指针指向n1

n1 = n2;

n2 = n3;

n3 = n3->next;

 

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

首先要判空

if(head == NULL)
    {
        return head;
    }

 

最后一步n3已经为NULL 故要添加限制语句

if(n3)
        {
            n3 = n3->next;
        }

3，单链表相关经典算法OJ题3：链表的中间结点

 876. 链表的中间结点 - 力扣（LeetCode）

给你单链表的头结点 head ，请你找出并返回链表的中间结点。

如果有两个中间结点，则返回第二个中间结点。

思路一

遍历链表，用count计算节点数，返回count/2节点或节点的next节点

思路二

快慢指针

slow每次走一步，fast每次走两步

 

 

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

注：不能写成

while(fast->next && fast)  

如果链表为偶数节点，fast最后一次走到NULL，fast->next会报错 

4，单链表相关经典算法OJ题4：合并两个有序链表

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

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

思路

创建新的空链表，遍历原链表，将节点值小的节点拿到新链表中进行尾插操作

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 ,*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;
        }
    }
    if(l2)
    {
        newTail->next = l2;
    }
    if(l1)
    {
        newTail->next = l1;
    }
    ListNode* ret = newHead->next;
    free(newHead);
    newHead = NULL;
    return ret;
}

先处理空链表情况

if(list1 == NULL)
    {
        return list2;
    }
    if(list2 == NULL)
    {
        return list1;
    }

 

跳出循环有两种情况

l1走到空

if(l2)
    {
        newTail->next = l2;
    }

l2走到空 

if(l1)
    {
        newTail->next = l1;
    }

 5，循环链表经典应⽤-环形链表的约瑟夫问题

著名的Josephus问题 据说著名犹太 Josephus有过以下的故事：在罗⻢⼈占领乔塔帕特后，39 个犹太⼈与 Josephus及他的朋友躲到⼀个洞中，39个犹太⼈决定宁愿死也不要被⼈抓到，于是决定了⼀个⾃杀 ⽅式，41个⼈排成⼀个圆圈，由第1个⼈开始报数，每报数到第3⼈该⼈就必须⾃杀，然后再由下⼀ 个重新报数，直到所有⼈都⾃杀⾝亡为⽌。 历史学家 然⽽Josephus 和他的朋友并不想遵从，Josephus要他的朋友先假装遵从，他将朋友与⾃⼰安排在 第16个与第31个位置，于是逃过了这场死亡游戏。

编号为 1 到 n 的 n 个人围成一圈。从编号为 1 的人开始报数，报到 m 的人离开。

下一个人继续从 1 开始报数。

n-1 轮结束以后，只剩下一个人，问最后留下的这个人编号是多少？

数据范围： 1≤𝑛,𝑚≤100001≤n,m≤10000

进阶：空间复杂度 𝑂(1)O(1)，时间复杂度 𝑂(𝑛)O(n)

思路

1，创建带环链表

2，计数

 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* creatCircle(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;
    return ptail;
}
int ysf(int n, int m ) {
    //1.根据n创建带环链表
    ListNode* prev = creatCircle(n);
    ListNode* pcur = prev->next;
    int count = 1;

    while(pcur->next != pcur)
    {
        if(count == m)
        {
            //销毁pcur节点
            prev->next = pcur->next;
            free(pcur);
            pcur = prev->next;
            count = 1;
        }
        else 
        {
            prev = pcur;
            pcur = pcur->next;
            count++;
        }
    }
    return pcur->val;
}

6，单链表相关经典算法OJ题5：分割链表

面试题 02.04. 分割链表 - 力扣（LeetCode）

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你不需要 保留 每个分区中各节点的初始相对位置。

 思路一

在原链表上进行修改，若pcur节点的值小于x，往后走；若pcur节点的值大于或等于x，尾插在原链表后，删除旧节点

思路二

创建新链表，遍历原链表

若pcur节点的值小于x，头插在新链表中

若pcur节点的值大于或等于x，尾插在新链表中

思路三

创建新链表：小链表和大链表

typedef struct ListNode ListNode;
struct ListNode* partition(struct ListNode* head, int x)
{
    if(head == NULL)
    {
        return head;
    }
    //创建两个带头链表
    ListNode* lessHead,*lessTail;
    ListNode* greaterHead,*greaterTail;
    lessHead = lessTail = (ListNode*)malloc(sizeof(ListNode));
    greaterHead = greaterTail = (ListNode*)malloc(sizeof(ListNode));
    //遍历原链表，将原链表中的节点尾插到大小链表中
    ListNode* pcur = head;
    while(pcur)
    {
        if(pcur->val <x)
        {
            lessTail->next = pcur;
            lessTail = lessTail->next;
        }
        else
        {
            greaterTail->next = pcur;
            greaterTail = greaterTail->next;
        }
        pcur = pcur->next;
    }
    greaterTail->next = NULL;
    lessTail->next = greaterHead->next;
    ListNode*ret = lessHead->next;
    free(lessHead);
    free(greaterHead);
    lessHead = greaterHead = NULL;
    return ret;

}

 greaterTail->next = NULL;

next指针初始化