✈移除链表元素
给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。
方法一：
遍历链表找到所有等于val的节点，再执行删除操作删除这些节点。
方法二：
双指针
创建两个指针，一个在前，一个在后。
如果前面的指针指向的元素等于val，将后面的指针连上前面指针的下一个指针，前面的指针向前走一格；
如果前面的指针指向的元素不等于val，那么两个指针都向前走一格。
再处理一些特殊情况：
struct ListNode* removeElements(struct ListNode* head, int val) {
ListNode * last = head;
ListNode* tmp = head;
if (last == NULL || (last->next == NULL && last->val == val))//如果是空链表或只有一个val的链表
{
return NULL;
}
else if (last->next == NULL)//如果只有一个节点且不等于val的链表
{
return head;
}
else
{
while (tmp != NULL)
{
if (tmp == last)
{
tmp = tmp->next;
}
if (tmp->val==val)
{
last->next = tmp->next;
tmp = tmp->next;
}
else
{
last = last->next;
tmp = tmp->next;
}
}
if (head->val == val)//如果第一个节点的元素就等于val
{
return head->next;
}
last->next = NULL;
}
return head;
}原题链接：
移除链表元素
✈反转链表
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
双指针法：
创建两个指针，一个在前，一个在后。
每次循环，将前面的指针指向的链表指向在后面的指针，后面的指针赋值成前一个，前一个往下走一格。
struct ListNode* reverseList(struct ListNode* head) {
if (head == NULL || head->next == NULL)//如果只有一个或者没有节点
{
return head;
}
ListNode* pre = head->next;
head->next = NULL;
while (pre != NULL)
{
ListNode* tmp = pre->next;
pre->next = head;
head = pre;
pre = tmp;
}
return head;
}原题链接：
反转链表
✈合并两个有序链表
双指针法：
创建三个指针，一个指向第一个链表，一个指向第二个链表，一个指向新链表的末尾。
如果第一个指针指向的元素比第二个指针小，那么就让新链表的末尾指向第一个指针，第一个指针再向后移一格，第三个指针向后移一格；
如果第二个指针指向的元素比第一个指针小，那么就让新链表的末尾指向第二个指针，第二个指针再向后移一格，第三个指针向后移一格。
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {
if (list1 == NULL)//先解决其中存在空链表的情况
{
return list2;
}
else if (list2 == NULL)
{
return list1;
}
else
{
ListNode* pre = NULL;
ListNode* finnal = NULL;
if (list1->val <= list2->val)//初始化pre，确定新链表的的头节点finnal
{
finnal = list1;
pre = list1;
list1 = list1->next;
}
else
{
finnal = list2;
pre = list2;
list2 = list2->next;
}
while (list1 != NULL && list2 != NULL)//取元素到新的链表中
{
if (list1->val <= list2->val)
{
pre->next = list1;
pre = list1;
list1 = list1->next;
}
else
{
pre->next = list2;
pre = list2;
list2 = list2->next;
}
}
if (list1 == NULL)
{
pre->next = list2;
}
else
{
pre->next = list1;
}
return finnal;
}
}原题链接：
合并两个有序链表
✈链表的中间节点
快慢指针法：
创建两个指针，一个快指针，一个慢指针，两个指针初始值为链表的起点。快指针每次走两格，慢指针每次走一格。
如果链表中有奇数个节点，当快指针的下一个节点为NULL时，慢指针走到中间节点的位置；
如果链表中有偶数个节点，当快指针为NULL时，慢指针走到中间节点的位置。
typedef struct ListNode ListNode;
struct ListNode* middleNode(struct ListNode* head) {
ListNode* fast = head;
ListNode* slow = head;
while (1)
{
if (fast == NULL || fast->next == NULL)
{
return slow;
}
fast = fast->next;
fast = fast->next;
slow = slow->next;
}
}原题链接：
链表的中间节点
✈环形链表的约瑟夫问题
环形链表法：
创建一个n个节点的环形链表，并且第n个节点的存储的元素是n。
删去第m个的值，并且循环n-1次。
typedef struct ListNode {
int val;
struct ListNode* next;
}ListNode;
int ysf(int n, int m) {
ListNode* head = (ListNode*)malloc(sizeof(ListNode));
assert(head);
head->val = 1;
head->next = head;
ListNode* pre = head;
for (int i = 2; i <=n; i++)
{
ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
newnode->next = head;
newnode->val = i;
pre->next = newnode;
pre = newnode;
}
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < m-1; j++)
{
pre = pre->next;
}
pre->next = pre->next->next;
}
return pre->val;
}原题链接：
环形链表的约瑟夫问题
