牛客101：链表 - 教程

目录

一、反转链表

二、链表内指定区间反转

三、链表中的节点每k个一组翻转

四、合并两个排序的链表

五、合并k个已排序的链表

六、判断链表中是否有环

七、链表中环的入口结点

八、链表中倒数最后k个结点

九、删除链表的倒数第n个节点

十、两个链表的第一个公共结点

十一、链表相加 II

十二、单链表的排序

十三、判断一个链表是否为回文结构

十四、链表的奇偶重排

十五、删除有序链表中重复的元素

十六、删除有序链表中重复的元素II

---

一、反转链表

反转链表_牛客题霸_牛客网

法一：双指针定位（必须掌握）

创建prev和cur的Node，prev先设置为nullptr，cur设置为head，先存一个t=cur->next（不然往后更新就找不到了），然后修改cur->next为prev，然后prev更新为cur，cur更新为存的t。最后返回prev，画个图很明了。

    ListNode* ReverseList(ListNode* head) {ListNode* prev=nullptr,*cur=head;while(cur!=nullptr){ListNode*tmp=cur->next;cur->next=prev;prev=cur;cur=tmp;}return prev;}

法二：递归

如果head是空直接返回

递归处理，递归退出条件是找到最后一个节点

每层处理的子问题就是让我此刻的head->next的箭头反转，并且head->next箭头也反转，此时因为还未到达上一层递归调用，先指向nullptr，这一步也是为了修改原始头结点的下一个为nullptr

    ListNode* ReverseList(ListNode* head) {if(!head||!head->next)return head;//找到最后一个节点ListNode*newnode=ReverseList(head->next);//处理每个子问题head->next->next=head;head->next=nullptr;//最后的这个节点作为头返回return newnode;}

二、链表内指定区间反转

链表内指定区间反转_牛客题霸_牛客网

单链表逆转往往涉及四个节点问题，可以先遍历，找到要逆转的起点，然后重复以下操作n-m次即可，每次更新后，cur恰好变成了我们想要的逆转那个节点，重复操作

1.t=cur->next；        存cur->next，此时t是我们要逆转它的方向的节点

2.存好cur->next后修改cur->next=t->next；让cur连接到下次的“t”

3.然后t->next=pre->next;        prev->next存的是上次的“t”将此刻的t->next=上次的"t"（prev->next）

4.prev->next=t;        更新prev->next（存的是每次逆转的那个节点)

既然我们需要prev这个节点，那么我们当我们的原始链表头结点需要操作的时候，就需要一个虚拟头结点

    ListNode* reverseBetween(ListNode* head, int m, int n) {ListNode* newhead=new ListNode(0);newhead->next=head;ListNode*prev=newhead,*cur=head;for(int i=1;inext;}//循环操作n-m次，可以举个特例n=m的时候就不需要逆转for(int i=m;inext;cur->next=t->next;t->next=prev->next;prev->next=t;}return newhead->next;}

三、链表中的节点每k个一组翻转

链表中的节点每k个一组翻转_牛客题霸_牛客网

可以提前设定一个Node（tail）从head开始往后走k步，确定逆转的终点，如果还没到k，tail就到末尾了，那么直接返回head就行，表示不用反转。

创建prev和cur的Node，prev先设置为nullptr，cur设置为head，存一个t=cur->next，然后修改cur->next为prev，然后prev更新为cur，cur更新为存的t。当cur=tail终止这个循环

最后我们让head->next指向以tail为头节点的递归结果即可。注意最后返回prev，画画图就明了了。

    ListNode* reverseKGroup(ListNode* head, int k) {ListNode*tail=head;//找到前k的节点后的一个节点//该节点既可以用在这层当作结束标志//也可以作为下一层的开始节点for(int i=0;inext;}ListNode*prev=nullptr,*cur=head;while(cur!=tail){//存一下下个节点ListNode*tmp=cur->next;//逆转cur->next=prev;//更新prev=cur;cur=tmp;}head->next=reverseKGroup(tail,k);return prev;}

四、合并两个排序的链表

合并两个排序的链表_牛客题霸_牛客网

很简单，因为单调性，所以双指针

    ListNode* Merge(ListNode* pHead1, ListNode* pHead2) {//虚拟头结点ListNode*newhead=new ListNode(-1);ListNode*tail=newhead;ListNode*cur1=pHead1,*cur2=pHead2;while(cur1&&cur2){if(cur1->valval){tail->next=cur1;cur1=cur1->next;}else{tail->next=cur2;cur2=cur2->next;}tail=tail->next;}if(cur1)tail->next=cur1;else tail->next=cur2;return newhead->next;}

五、合并k个已排序的链表

合并k个已排序的链表_牛客题霸_牛客网

先思考暴力思路是怎样的：因为之前我们写过一道题叫合并两个升序链表。那么我们可以先合并前两个，然后再让这个合并的链表跟第三个合并，然后再依次这样合并下去就能完成。这其实很有一股递归的味道。

法一：优先级队列，使得操作很简单

class Solution {
public:struct cmp{bool operator()(ListNode* l1,ListNode* l2){return l1->val > l2->val;}};ListNode* mergeKLists(vector& lists) {//创建小根堆（greater）priority_queue,cmp> heap;//放头节点for(auto l:lists)if(l)heap.push(l);//可能会有空数组ListNode* ret=new ListNode(0),*tail=ret;//比较各个数组中哪个更小，添加到链表while(!heap.empty()){ListNode*t=heap.top();heap.pop();tail->next=t;tail=tail->next;//让插入链表的那个节点下一个节点继续入小根堆if(t->next)heap.push(t->next);}tail=ret->next;delete ret;return tail;}
};

法二：分治

其实很容易想到分治，将数组无限缩小，缩小到只有两个，处理这两个（根据快排归并排序的思路），但是怎么找到每段的头的位置，我去突然发现这里是数组，可以直接找了。

class Solution {
public:ListNode* mergeKLists(vector& lists) {return mergeSort(lists,0,lists.size()-1);}ListNode* mergeSort(vector&lists,int left,int right){//边界处理if(left>right)return nullptr;if(left==right)return lists[left];//分治int mid=(left+right)>>1;ListNode* l=mergeSort(lists,left,mid);ListNode* r=mergeSort(lists,mid+1,right);//合并return mergeTwoList(l,r);}ListNode* mergeTwoList(ListNode*list1,ListNode*List2){if(list1==nullptr)return List2;if(List2==nullptr)return list1;ListNode*cur1=list1,*cur2=List2;ListNode* head=new ListNode(0),*tail=head;while(cur1&&cur2){if(cur1->val<=cur2->val){tail->next=cur1;cur1=cur1->next;}else{tail->next=cur2;cur2=cur2->next;}tail=tail->next;}//没有弄完的直接连接就行，后边都是串起来的if(cur1)tail->next=cur1;if(cur2)tail->next=cur2;tail=head->next;delete head;return tail;}
};

六、判断链表中是否有环

判断链表中是否有环_牛客题霸_牛客网

判环的经典思路就是快慢指针

class Solution {
public:bool hasCycle(ListNode *head) {ListNode*fast=head,*slow=head;while(fast&&fast->next){fast=fast->next->next;slow=slow->next;if(fast==slow)return true;}return false;}
};

七、链表中环的入口结点

链表中环的入口结点_牛客题霸_牛客网

class Solution {
public:ListNode* hasCycle(ListNode *head) {ListNode*fast=head,*slow=head;while(fast&&fast->next){fast=fast->next->next;slow=slow->next;if(fast==slow)return slow;}return nullptr;}ListNode* EntryNodeOfLoop(ListNode* pHead) {ListNode*cur1=hasCycle(pHead);if(cur1==nullptr)return nullptr;ListNode*cur2=pHead;while(cur1!=cur2){cur1=cur1->next;cur2=cur2->next;}return cur1;}
};

八、链表中倒数最后k个结点

链表中倒数最后k个结点_牛客题霸_牛客网

第一眼思路就是先遍历链表看有多少个结点，n，然后再次遍历，遍历到第n-k+1个结点，返回这个结点。其实就是官方解答的方法二

    ListNode* FindKthToTail(ListNode* pHead, int k) {ListNode*cur=pHead;int n=0;while(cur){++n;cur=cur->next;}cur=pHead;int times=n-k;if(times<0)return nullptr;while(times--){cur=cur->next;}return cur;}

官方题解是快慢指针的思想，先让fast走k步，然后再一起走，fast=nullptr的时候slow到末尾就是k个结点，

class Solution {
public:ListNode* FindKthToTail(ListNode* pHead, int k) {ListNode* fast = pHead;ListNode* slow = pHead;//快指针先行k步for(int i = 0; i < k; i++){if(fast != NULL)fast = fast->next;//达不到k步说明链表过短，没有倒数kelsereturn slow = NULL;//这种方式是先将NULL赋值给slow再返回slow}//快慢指针同步，快指针先到底，慢指针指向倒数第k个while(fast != NULL){fast = fast->next;slow = slow->next;}return slow;}
};

九、删除链表的倒数第n个节点

删除链表的倒数第n个节点_牛客题霸_牛客网

还是找倒数第n个节点的问题，那么思路和上一题大差不差。

先用快慢指针写，因为要删除这个值，所以我们存一下slow前面的一个节点等会删掉slow

    ListNode* removeNthFromEnd(ListNode* head, int n) {ListNode*fast=head,*slow=fast;while(n--){if(fast)fast=fast->next;else return nullptr;}ListNode*newhead=new ListNode(-1),*prev=newhead;newhead->next=head;while(fast){fast=fast->next;slow=slow->next;prev=prev->next;}prev->next=slow->next;delete slow;prev=newhead->next;delete newhead;return prev;}

再用先找总结点个数的方法

    ListNode* removeNthFromEnd(ListNode* head, int n) {//计算节点总个数ListNode*cur=head;int count=0;while(cur){++count;cur=cur->next;}int times=count-n;if(times<0)return nullptr;//创建虚拟头结点，cur从头开始ListNode*newhead=new ListNode(-1),*prev=newhead;newhead->next=head;cur=head;while(times--){cur=cur->next;prev=prev->next;}prev->next=cur->next;delete cur;prev=newhead->next;delete newhead;return prev;}

十、两个链表的第一个公共结点

两个链表的第一个公共结点_牛客题霸_牛客网

熟悉的题目，第一次见是在抖y上刷到，后来在别的平台写了一次，后面又在笔试训练的时候刷到。

class Solution {public:ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {if (!pHead1 || !pHead2) return nullptr;ListNode*cur1=pHead1,*cur2=pHead2;while(cur1!=cur2){cur1=cur1?cur1->next:pHead2;cur2=cur2?cur2->next:pHead1;}return cur1;}
};

十一、链表相加 II

链表相加(二)_牛客题霸_牛客网

其实就是高精度加法模拟，之前做过一道还帮我们逆转好了链表，这题还要我们自己逆转，真是可恶。不过链表逆转我们已经很熟悉了，高精度加法也刷过很多次了，无非就是1+1=2的问题。

class Solution {
public:ListNode* ReverseNode(ListNode*head){if(!head||!head->next)return head;ListNode* newhead=ReverseNode(head->next);head->next->next=head;head->next=nullptr;return newhead;}// ListNode* ReverseNode(ListNode*head)// {//     ListNode*prev=nullptr;//     ListNode*cur=head;//     while(cur)//     {//         ListNode*t=cur->next;//         cur->next=prev;//         prev=cur;//         cur=t;//     }//     return prev;// }ListNode* addInList(ListNode* head1, ListNode* head2) {//逆转链表ListNode*cur1=ReverseNode(head1),*cur2=ReverseNode(head2);int add=0;ListNode*newhead=new ListNode(-1);while(cur1||cur2||add){if(cur1){add+=cur1->val;cur1=cur1->next;}if(cur2){add+=cur2->val;cur2=cur2->next;}//头插ListNode*Node=new ListNode(add%10);Node->next=newhead->next;newhead->next=Node;add/=10;}ListNode*prev=newhead->next;delete newhead;return prev;}
};

十二、单链表的排序

单链表的排序_牛客题霸_牛客网

666昨天学校布置的作业就写到这个，刚好今天当作复习了

解法一：冒泡排序

链表的冒泡排序（真）不过这不符合题目要求这里我只是展示一下链表的冒泡如何操作

    ListNode* sortInList(ListNode* head) {if(!head||!head->next)return head;ListNode* newhead=new ListNode(-1),*prev,*cur;newhead->next=head;bool flag;do{//更新flag!!!flag=false;prev=newhead;cur=head;//NextNode始终是cur下一个要比较的结点ListNode* NextNode=cur->next;while(NextNode){if(cur->val>NextNode->val){cur->next=NextNode->next;NextNode->next=cur;prev->next=NextNode;prev=NextNode;flag=true;}else {prev=cur;cur=cur->next;}NextNode=cur->next;}}while(flag);prev=newhead->next;delete newhead;return prev;}

虚假的链表冒泡排序，也就是只交换val

    ListNode* sortInList(ListNode* head) {if(!head||!head->next)return head;ListNode*cur;bool flag;do{//更新flag!!!flag=false;cur=head;//NextNode始终是cur下一个要比较的结点ListNode* NextNode=cur->next;while(NextNode){if(cur->val>NextNode->val){int tmp=cur->val;cur->val=NextNode->val;NextNode->val=tmp;}cur=cur->next;NextNode=cur->next;}}while(flag);return head;}

解法二：归并排序（分治）

题目要求时间复杂度nlogn，那不就是分治了

创建快慢指针->分

排序->治

    ListNode* merge(ListNode*pHead1,ListNode*pHead2){if(!pHead1)return pHead2;if(!pHead2)return pHead1;ListNode* head=new ListNode(0),*cur=head;while(pHead1&&pHead2){if(pHead1->valval){cur->next=pHead1;pHead1=pHead1->next;}else {cur->next=pHead2;pHead2=pHead2->next;}//注意移动指针！！！cur=cur->next;}if(pHead1)cur->next=pHead1;if(pHead2)cur->next=pHead2;cur=head->next;delete head;return cur;}ListNode* sortInList(ListNode* head) {if(!head||!head->next)return head;ListNode*left=head,*mid=head->next,*right=mid->next;while(right&&right->next){left=left->next;mid=mid->next;right=right->next->next;}//断开两个链表，分！left->next=nullptr;//不断在sortInList里分，分，分return merge(sortInList(head),sortInList(mid));}

解法三：转换为数组排序

说实话我感觉这种方法有点偷懒哈哈哈，最先想到的也是这个，果然大脑还是喜欢偷懒

    ListNode* sortInList(ListNode* head) {vector nums;ListNode*cur=head;//数据push进数组while(cur){nums.push_back(cur->val);cur=cur->next;}cur=head;sort(nums.begin(),nums.end());for(int i=0;ival=nums[i];cur=cur->next;}return head;}

十三、判断一个链表是否为回文结构

判断一个链表是否为回文结构_牛客题霸_牛客网

解法一：存进数组

也是借鉴了上一题，然后判断，不过感觉这样写很耍赖

    bool isPail(ListNode* head) {vector nums;ListNode*cur=head;while(cur){nums.push_back(cur->val);cur=cur->next;}for(int left=0,right=nums.size()-1;left<=right;++left,--right){if(nums[left]!=nums[right])return false;}return true;}

解法二：逆转链表+双指针

从中间位置断开，逆转后部分链表，然后双指针判断

或者像这样用头插实现逆转

    bool isPail(ListNode* head) {ListNode*dummy=new ListNode(0),*cur1=head;while(cur1){ListNode*node=new ListNode(cur1->val);node->next=dummy->next;dummy->next=node;//不要忘记移动cur1！cur1=cur1->next;}ListNode*cur2=dummy->next;cur1=head;while(cur1){if(cur1->val!=cur2->val)return false;cur1=cur1->next;cur2=cur2->next;}return true;}

找中点，再逆序的写法：

    ListNode* ReverseList(ListNode* head){if(!head||!head->next)return head;ListNode*newnode=ReverseList(head->next);head->next->next=head;head->next=nullptr;return newnode;}bool isPail(ListNode* head) {ListNode*slow=head,*fast=head;while(fast&&fast->next){slow=slow->next;fast=fast->next->next;}ListNode* ReverseHead=ReverseList(slow);ListNode*cur1=head,*cur2=ReverseHead;//奇偶统一，cur1&&cur2，有可能cur2先结束，所以要算上cur2while(cur1&&cur2){if(cur1->val!=cur2->val)return false;cur1=cur1->next;cur2=cur2->next;}return true;}

解法三：栈

先将数据全部存进栈，每次从栈顶取出的元素就是逆序的

    bool isPail(ListNode* head) {stack st;ListNode*cur=head;while(cur){st.push(cur->val);cur=cur->next;}cur=head;while(!st.empty()){if(st.top()!=cur->val)return false;st.pop();cur=cur->next;}return true;}

十四、链表的奇偶重排

链表的奇偶重排_牛客题霸_牛客网

朴素解法：

ListNode* oddEvenList(ListNode* head) {if(!head||!head->next||!head->next->next)return head;ListNode*cur=head,*newnode=new ListNode(0),*p=newnode;while(cur){//不能直接指向cur1，要创建新结点p->next=new ListNode(cur->val);p=p->next;//cur->next不存在说明是尾部，那么得置为nullptr，//开始时没有做处理导致死循环了emmcur=cur->next?cur->next->next:nullptr;}cur=head->next;while(cur){p->next=new ListNode(cur->val);p=p->next;cur=cur->next?cur->next->next:nullptr;}p=newnode->next;delete newnode;return p;}

题解：相当于在原链表上直接修改指向

class Solution {
public:ListNode* oddEvenList(ListNode* head) {//如果链表为空，不用重排if(head == NULL)return head;//even开头指向第二个节点，可能为空ListNode* even = head->next;//odd开头指向第一个节点ListNode* odd = head;//指向even开头ListNode* evenhead = even;while(even != NULL && even->next != NULL){//odd连接even的后一个，即奇数位odd->next = even->next;//odd进入后一个奇数位odd = odd->next;//even连接后一个奇数的后一位，即偶数位even->next = odd->next;//even进入后一个偶数位even = even->next;}//even整体接在odd后面odd->next = evenhead;return head;}
};

十五、删除有序链表中重复的元素

删除有序链表中重复的元素-I_牛客题霸_牛客网

法一：双指针

本来还写了排序的，后来发现题目里的链表是排好的，法科

#include 
class Solution {
public:// ListNode*merge(ListNode*pHead1,ListNode*pHead2)// {//     ListNode*newhead=new ListNode(0),*cur=newhead;//     while(pHead1&&pHead2)//     {//         if(pHead1->valval)//         {//             cur->next=pHead1;//             pHead1=pHead1->next;//         }//         else {//             cur->next=pHead2;//             pHead2=pHead2->next;//         }//         cur=cur->next;//     }//     if(pHead1)cur->next=pHead1;//     if(pHead2)cur->next=pHead2;//     cur=newhead->next;//     delete newhead;//     return cur;// }// ListNode* SortList(ListNode*head)// {//     if(!head||!head->next)return head;//     ListNode*left=head,*mid=head->next,*right=mid->next;//     while(right&&right->next)//     {//         left=mid;//         mid=right;//         right=right->next;//     }//     left->next=nullptr;//     return merge(SortList(head),SortList(mid));// }ListNode* deleteDuplicates(ListNode* head) {if(!head||!head->next)return head;//ListNode* NewHead=SortList(head);//cur存不重复的当前结点，next负责遍历ListNode*cur=head,*next=cur->next;while(next){if(next->val==cur->val)next=next->next;else{cur->next=next;cur=next;next=cur->next;}}//断开后续所有结点cur->next=nullptr;return head;}
};

解法二：单指针简单遍历即可

官方代码用单指针也可以实现：推荐

    ListNode* deleteDuplicates(ListNode* head) {if(!head||!head->next)return head;ListNode*cur=head;while(cur&&cur->next){if(cur->val==cur->next->val){//跳过cur->nextcur->next=cur->next->next;}//遇到不等的了，说明当前和cur相等的val已经全部跳过//cur->next存的是下一个要处理的val，更新curelse cur=cur->next;}return head;}

十六、删除有序链表中重复的元素II

删除有序链表中重复的元素-II_牛客题霸_牛客网

这次出现次数大于1的直接被删了，就像玩开心消消乐那样

现在就是如果cur->next的值与cur的值相等，那么cur是被跳过的那个，如果开头第一个元素就是跳过的，为了方便操作，我们引入虚拟头结点。思路重在修改指向。

    ListNode* deleteDuplicates(ListNode* head) {if (!head || !head->next)return head;//创建新表头，直接从新表头开始修改方向ListNode* newhead = new ListNode(0), *cur = newhead;newhead->next = head;while (cur ->next&& cur->next->next) {//相等跳过这一整段if (cur->next->val == cur->next->next->val) {int tmp=cur->next->val;while (cur->next && cur->next->val==tmp) {cur ->next=cur->next->next;}}//不等的表示符合，cur直接找下一个结点else {cur=cur->next;}}cur= newhead->next;delete newhead;return cur;}

链表结束。