淄博桓台学校网站建设哪家好安徽网络优化公司排名

移除链表元素

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

示例 1：

输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]

示例 2：

输入：head = [], val = 1 输出：[]

示例 3：

输入：head = [7,7,7,7], val = 7 输出：[]

提示：

列表中的节点数目在范围 [0, 104] 内
1 <= Node.val <= 50
0 <= val <= 50

题目链接：link

本题不同于基本操作中的头删尾删等，因为头结点也有可能是要删掉的，那这个时候就比较麻烦了，所以我们最好是重新定义一个链表，遍历原链表不为val的节点，尾插在新链表中。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* create(int x)
{struct ListNode* new=(struct ListNode*)malloc(sizeof(struct ListNode));new->val=x;new->next=NULL;return new;
}
void PushBack(struct ListNode** pp,int x,struct ListNode** ppt)
{struct ListNode* new=create(x);if(*pp==NULL){*pp=new;*ppt=new;return;}(*ppt)->next=new;(*ppt)=(*ppt)->next;
}struct ListNode* removeElements(struct ListNode* head, int val) {struct ListNode* newhead=NULL;struct ListNode* tail=NULL;struct ListNode* cur=head;while(cur!=NULL){if(cur->val!=val)PushBack(&newhead,cur->val,&tail);cur=cur->next;}return newhead;
}

另外官方题解用了递归迭代的方式也很值得学习：

迭代：

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
struct ListNode* removeElements(struct ListNode* head, int val) {struct ListNode* dummyHead=(struct ListNode*)malloc(sizeof(struct ListNode));dummyHead->next=head;struct ListNode* cur=dummyHead;while(cur->next!=NULL){if(cur->next->val==val)cur->next=cur->next->next;elsecur=cur->next;}return dummyHead->next;
}

递归的话，反正我是理解的不太好（每次都得画好久递归图才能理解呜呜呜）

struct ListNode* removeElements(struct ListNode* head, int val) {if (head == NULL) {return head;}head->next = removeElements(head->next, val);return head->val == val ? head->next : head;
}

链表的中间节点

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

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

示例 1：

输入：head = [1,2,3,4,5] 输出：[3,4,5] 解释：链表只有一个中间结点，值为 3 。

示例 2：

输入：head = [1,2,3,4,5,6] 输出：[4,5,6] 解释：该链表有两个中间结点，值分别为 3 和 4 ，返回第二个结点。

题目链接：link
这道题的思路是：设置两个指针，一个slow指针，一个fast指针，slow指针一次走一步，fast指针一次走两步，当fast或fast的next为空的时候，slow就是我们要找的中间节点。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
typedef struct ListNode LN;
struct ListNode* middleNode(struct ListNode* head) {LN* slow=head;LN* fast=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;}return slow;
}

反转链表

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

示例 1：

输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1]

示例 2：

输入：head = [1,2] 输出：[2,1]

示例 3：

输入：head = [] 输出：[]

题目链接：link

这道题的思路非常精巧。
设立三个指针，n1，n2和n3，分别指向NULL，头结点和头结点的next。
当n2不为空的时候，将n2的next指向n1，然后将n3赋值给n2（这也是n3存在的意义，因为改变n2的next指针以后，n2就无法通过n2=n2->next语句访问到原链表的下一个指针了）n3=n3->next，n1=n2；

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

当然n3也可以不用一开始就定义，也可以在循环中当做一个临时变量：

struct ListNode* reverseList(struct ListNode* head) {struct ListNode* prev = NULL;struct ListNode* curr = head;while (curr) {struct ListNode* next = curr->next;//在这里设置n3，就不用单独考虑head是否为空或者只有一个节点的情况了curr->next = prev;prev = curr;curr = next;}return prev;
}

合并两个有序链表

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

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4] 输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = [] 输出：[]

示例 3：

输入：l1 = [], l2 = [0] 输出：[0]

题目链接：link
设置四个指针，l1遍历链表1，l2遍历链表2，newhead是新链表头结点（哨兵位），newtail是新链表尾指针，l1和l2比较，谁小谁尾插到newtail后，然后向后走一位，没有尾插的不动，直到l1或l2有一方为空，再把没有遍历完的那个链表的剩余部分直接尾插到newtail后面。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/
typedef struct ListNode LN;
struct ListNode* mergeTwoLists(struct ListNode* list1, struct ListNode* list2) {LN* l1=list1;LN* l2=list2;LN* newhead=(LN*)malloc(sizeof(LN));LN* tail=newhead;if(l1==NULL&&l2==NULL)return NULL;while(l1&&l2){if(l1->val<=l2->val){tail->next=l1;l1=l1->next;}else{tail->next=l2;l2=l2->next;}tail=tail->next;}if(l1==NULL){tail->next=l2;}else{tail->next=l1;}return newhead->next;
}

分割链表

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

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

示例 1：

输入：head = [1,4,3,2,5,2], x = 3 输出：[1,2,2,4,3,5]

示例 2：

输入：head = [2,1], x = 2 输出：[1,2]

题目链接：link

大小链表法，新设两个链表一个放小的，一个放大的，然后最后把他们拼起来。

/*** Definition for singly-linked list.* struct ListNode {*     int val;*     struct ListNode *next;* };*/typedef struct ListNode LN;
struct ListNode* partition(struct ListNode* head, int x){LN* s=(LN*)malloc(sizeof(LN));LN* b=(LN*)malloc(sizeof(LN));LN* st=s;LN* bt=b;LN* cur=head;while(cur){if(cur->val<x){st->next=cur;st=st->next;}else{bt->next=cur;bt=bt->next;}cur=cur->next;}bt->next=NULL;st->next=b->next;}

这个题要注意的是，最后在处理bt->next，也就是大链表的最后时一定要记得“封尾”，也就是要给他赋值为NULL，因为我们在把原链表中的节点挪到新的大小链表中的时候，连同他的next指针一起挪动了，那也就是说，如果不“封尾”，那么大链表的最后一个元素后还连着他在原链表中的后继元素。

好了今天的分享就结束了，马上又要期末考试啦！期中数据结构得了满分，希望期末可以继续保持下去！！！下学期就是真正的软工人啦~