初学者练习代码准备机试（六）反转链表Ⅰ、Ⅱ，k个一组翻转链表-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_77456778/article/details/145910360

大家好，今天我学习了灵神的第六节课，内容是反转链表的两道题和k个一组翻转链表，感兴趣的小伙伴就看下去吧！

反转链表

原题在这里206. 反转链表 - 力扣（LeetCode），首先我们简单回忆一下链表的结构，每个链表元素包含两个区域，一个是数据域，一个是指针域。为了解决这个题目，我们应该设置三个链表中的结点，一个指向当前处理的结点cur,一个指向当前结点的前一个结点，叫pre,一个指向当前结点的下一个结点，叫做nxt;然后使用while循环，如果cur不为空，表示cur还没到链表末尾，就将当前结点指针的next域反转，然后三个指针分别后移，全部反转之后pre指向链表的最后一个节点，即此时的头节点，最后返回pre即可。完整代码如下：

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
    ListNode* pre=nullptr;//指向当前结点的前一个结点
    ListNode* cur=head;
    while(cur)//循环到cur指向空，也就是链表末尾结束
    {
        ListNode* nxt=cur->next;//nxt指针存放当前结点的下一个结点
        cur->next=pre;//当前节点的next域指向pre,实现反转
        pre=cur;//pre后移到当前结点
        cur=nxt;//同理cur也后移
    }
    return pre;
    }
};

反转链表Ⅱ

对于反转后的链表，我们应该把握一个性质，那就是pre应该指向反转这段的最后一个节点，cur指向这一段的下一个节点。

比如题目这道题，要求我们反转234再与原来链接，发现其实就是先处理中间这段，让1节点指向此时的pre(4节点)，再让2节点指向此时的cur(5节点)，这个时候5个节点就连起来了，成为了顺序为1、4、3、2、5的链表。

我们把反转这一段的上一个节点叫做p0,那么就是p0->next指向cur,p0指向pre。这个时候还有一种情况没有解决，就是如果left=1,也就是需要反转的是从第一个节点开始，那么p0此时是没有节点的，我们可以设置一个哨兵节点，这时候p0就有指向的了。

因此，我们整体代码的思路是，首先设置哨兵节点，也就是虚拟头节点，然后移动哨兵节点到达left的前一个节点处，然后开始处理反转，和上一题一样的思路，设置pre,cur,nxt，注意这里的for循环right-left+1是被反转的节点个数，但是反转移动的指针数是right-left个，所以是i<(right-left+1),比如题目当中应该是3个节点反转，处理时候只用处理两个指针就可以处理好。剩下就用上面提到的思路，即可完成，完整代码如下：

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
        ListNode dummy(0,head);//设立一个哨兵节点
        ListNode* p0=&dummy;//让p0指向哨兵节点
        for(int i=0;i<left-1;i++)
        {
            p0=p0->next;//让虚拟头节点一直移动到反转这一段的前一个节点
        }
        ListNode* pre=nullptr;
        ListNode* cur=p0->next;
        for(int i=0;i<right-left+1;i++)
        {
            ListNode* nxt=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nxt;
        }
        p0->next->next=cur;
        p0->next=pre;
        return dummy.next;
    }

};

k个一组翻转链表

原题在这里25. K 个一组翻转链表 - 力扣（LeetCode），首先，我们可以判断一下链表长度，链表长度>=k是可以翻转的，如果小于k直接退出循环，然后对每一组的小链表反转的思路和第一题是完全类似的，但是我们需要做一个额外的工作，就是在每次翻转之后，把p0更新成下一段要反转的链表的上一个节点，比如下图当中，我们已经处理完12节点，接着想处理34节点，就应该让p0指向34的前一个节点，也就是翻转12后的1节点，那1节点其实也是p0的next，但是又由于我们会修改p0的next，因此我们在修改之前设置一个临时变量nxt把p0->next记录下来，修改完了再把p0更新成nxt，就可以开始下一次循环了。

经过不断的循环，最后返回哨兵节点的next作为头节点即可，完整代码如下:

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {
       int n=0;
       ListNode* cur=head;
       while(cur)
       {
        n++;
        cur=cur->next;//使用一个计数器n拿到链表长度
       }
        ListNode dummy(0,head);//设立一个哨兵节点
        ListNode* p0=&dummy;//让p0指向哨兵节点
        cur = p0->next; // 让 cur 重新指向当前组的第一个节点
        ListNode* pre=nullptr;
        while(n>=k)//剩余节点个数大于等于k就循环
        {
            n-=k;
            for(int i=0;i<k;i++)
           {
            ListNode* nxt=cur->next;
            cur->next=pre;
            pre=cur;
            cur=nxt;
           }
        ListNode* nxt=p0->next;
        p0->next->next=cur;
        p0->next=pre;
        p0=nxt;
        }
        return dummy.next;
    }
};

注意代码中一个问题，那就是每次要让cur更新一下，指向当前处理小链表组的第一个节点，要不然会报错。

好了，小伙伴们，今天的学习到这里就结束了，如果有什么问题欢迎各位小伙伴在评论区与我交流，我们明天见！