✈移除链表元素

给你一个链表的头节点 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;
}

 原题链接：

环形链表的约瑟夫问题