C语言单向链表的经典算法

1.分割链表

2.移除链表元素

3.反转链表

4.合并两个有序链表

5.链表的中间结点

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

1.分割链表:

1.思路：创建新链表，小链表和大链表。如图

代码如下

/*** 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* 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(greaterHead);
free(lessHead);
greaterHead = lessHead = NULL;
return ret;
}

2.移除链表元素 ：思路：链表中不为val则尾插到新链表中。（最后新链表应该置为空）指针pcur往后移动pphead不动。刚开始新链表为空，注意每次尾插都要，把该节点定位尾节点。

代码：

#define _CRT_SECURE_NO_WARNINGS 1
/*** 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* newhead = NULL;ListNode* newtail = NULL;//遍历原链表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;
}

3.反转链表：思路：创建三个指针完成原链表的翻转

看这个视频：

反转链表

代码：

#define _CRT_SECURE_NO_WARNINGS 1
/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
typedef struct ListNode ListNode;
struct ListNode* reverseList(struct ListNode* head) {if (head == NULL){return head;}ListNode* n1, * n2, * n3;n2 = head;n1 = NULL;n3 = n2->next;while (n2){n2->next = n1;n1 = n2;n2 = n3;if (n3)n3 = n3->next;}return n1;
}

4.合并两个有序链表：创建新的空链表，遍历原链表，将节点小的链表拿到新链表中尾插。（遍历结果有两种情况，l1为空或者l2为空）。

代码：

#define _CRT_SECURE_NO_WARNINGS 1
/*** 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;}ListNode* l1 = list1;ListNode* l2 = list2;ListNode* newtail, * newhead;newhead = newtail = (ListNode*)malloc(sizeof(ListNode));while (l1 && l2){if (l1->val < l2->val){//l1拿下来尾插newtail->next = l1;newtail = newtail->next;l1 = l1->next;}else {//l2尾插newtail->next = l2;newtail = newtail->next;l2 = l2->next;}}//跳出循环时有两种情况，l1先为空 或 l2先为空if (l2){newtail->next = l2;}if (l1){newtail->next = l1;}ListNode* ret = newhead->next;free(newhead);newhead = NULL;return ret;
}

5.链表的中间结点：思路：这里可以定义两个快慢指针，快指针一次走两步，慢指针一次走两步（这里也要注意条件不能交换位置，两种情况都保证的情况下先满足小的，链表为偶数时fast最后一次会直接走到空，下一步就会报错）

代码：

#define _CRT_SECURE_NO_WARNINGS 1
/*** 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){slow = slow->next;fast = fast->next->next;}return slow;
}

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

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

2.思路：第一步创建环形链表（创建之前要先创建一个节点，可以用函数封装起来），第二步计数（又分为销毁链表和不销毁链表）下面我画了图以视频形式呈现

环形链表的约瑟夫问题