[LeetCode] 链表反转

[LeetCode] 链表反转专题

---

206. 反转链表

难度：Easy

题目描述：

反转一个单链表。

示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

解题思路：

方法1：头插法
新建一个dummy结点，作为开始的结点。
依次将链表中的元素插入dummy结点的后面。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* dummy = new ListNode(0);
        dummy->next = NULL;         // dummy结点下一个要置空，不能指向head
        ListNode* now = head;
        
        while(now){
            ListNode* temp = now->next;
            now->next = dummy->next;
            dummy->next = now;
            now = temp;
        }
        
        return dummy->next;
    }
};

方法2：顺序反转指针
依次按顺序反转指针

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = NULL;
        ListNode* cur = head;
        while(cur) {
            ListNode* temp = cur->next; //temp存放当前结点的下一个节点的地址
            cur->next = pre; //当前结点指向前一个结点
            pre = cur; //pre往前走一个结点
            cur = temp; //cur也走到下一个结点，重复上述步骤
        }
        return pre;
    }
};

---

92. 反转链表 II

难度: Medium

题目描述：

反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。

说明:
1 ≤ m ≤ n ≤ 链表长度。

示例:

输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL

解题思路:

方法1：头插法

class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int m, int n) {

        ListNode* dummy = new ListNode(0);
        ListNode* pre = dummy;
        ListNode* cur;
        dummy->next = head;

        // pre指向第m-1个
        for (int i = 0; i < m - 1; i++){
            pre = pre->next;
        }

        cur = pre->next;

        // 前插n-m次到pre后面
        for (int i = 0; i < n - m; i++){
            ListNode* temp = pre ->next;
            pre->next = cur->next;
            cur->next = cur ->next->next;
            pre->next->next = temp;
        }

        return dummy->next;
    }
};

---

25. K 个一组翻转链表

难度:Hard

题目描述：

给你一个链表，每 k 个节点一组进行翻转，请你返回翻转后的链表。

• k 是一个正整数，它的值小于或等于链表的长度。

• 如果节点总数不是 k 的整数倍，那么请将最后剩余的节点保持原有顺序。

示例：

给你这个链表：1->2->3->4->5

当 k = 2 时，应当返回: 2->1->4->3->5

当 k = 3 时，应当返回: 3->2->1->4->5

解题思路：

• 设计一个辅助函数reverse(ListNode* pre, ListNode* next),用于反转pre,next中间的结点(不包括两个锻炼)，返回pre->next，即反转前的第一个结点（反转后的最后一个）。
• 主函数中遍历原链表，每到k个传入reverse中进行反转。
• 返回的结点时pre, cur = pre ->next;

class Solution {
public:
    ListNode* reverseKGroup(ListNode* head, int k) {

        if (!head || k == 1)
        {
            return head;
        }

        ListNode* dummy = new ListNode(-1);     // 辅助节点，帮助记录目前的头结点
        ListNode* pre = dummy;                  // 记录需要反转组的前一个节点
        ListNode* cur = head;                   // 遍历链表时的节点
        
        dummy->next = head;

        for (int i = 1; cur; i++)
        {
            if (i % k == 0)         // 每k组做一次反转
            {
                pre = reverse(pre, cur->next);
                cur = pre->next;    // 反转之后，原来的头结点变为了尾节点，并且已经和下一段连接上了
            }else
            {
                cur = cur->next;
            }
        }
        
        return dummy->next;         // 借助一个虚拟节点，在头结点不断变化的时候，还能确定反转后的头结点
    }

    /*
      反转pre next之间的链表，返回反转之后尾指针
    */
    ListNode* reverse(ListNode* pre, ListNode* next) {
        ListNode* last = pre->next; // 这个指针是反转之后最后一个节点
        ListNode* cur = last->next; // 从此处开始交换

        while (cur != next) // 头插入式反转链表
        {
            last->next = cur->next;
            cur->next = pre->next;
            pre->next = cur;
            cur = last->next;
        }
        
        return last;    // 返回的是该组的第一个的指针
    }
    
};