编程训练第七十期——反转链表 II

编程问题：

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

---

示例：

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

---

解法：

1.迭代反转
时间复杂度O(N)
空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
    	// h结点作为head链表的头结点。h结点的next结点为head的第一个数据结点。
        // pre指针指向需要进行反转的结点的前驱结点，用于进行结点反转。
        // temp指针指向需要进行反转的结点的后继结点，用于存储引用。
        // font指针指向进行反转之前的前驱结点，用于连接反转之后的结点。
        // rear指针指向反转之后最后一个结点，用于连接余下的结点。
        // cur指针指向head链表的开始结点，用于遍历head链表。
        ListNode *pre = nullptr;
        ListNode *h = new ListNode(0);
        h->next = head;
        ListNode *font = h;
        ListNode *rear = nullptr;
        ListNode *cur = head;
        int number = 0;
        while (cur)
        {
            number++;
            if (number == left)
            {
                ListNode *temp = cur->next;
                cur->next = pre;
                pre = cur;
                rear = cur;
                cur = temp;
            }
            else if (number > left && number <= right)
            {
                ListNode *temp = cur->next;
                cur->next = pre;
                pre = cur;
                cur = temp;
            }
            else if (number < left)
            {
                font = cur;
                cur = cur->next;
            }
            else
            {
                break;
            }
        }
        rear->next = cur;
        font->next = pre;
        return h->next;
    }
};

2.迭代头插
时间复杂度O(N)
空间复杂度O(1)

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    ListNode* reverseBetween(ListNode* head, int left, int right) {
    	// h结点作为head链表的头结点。h结点的next结点为head的第一个数据结点。
        // temp指针指向需要进行头插的结点，用于头插。
        // font指针指向进行头插的前驱结点，用于在其指向的结点后插入结点。
        // rear指针指向进行头插之后最后一个结点，用于连接余下的结点。
        // cur指针指向head链表的开始结点，用于遍历head链表。
        ListNode *h = new ListNode(0);
        h->next = head;
        ListNode *font = h;
        ListNode *rear = nullptr;
        ListNode *cur = head;
        int number = 0;
        while (cur)
        {
            number++;
            if (number == left)
            {
                rear = cur;
                cur = cur->next;
            }
            else if (number > left && number <= right)
            {
                ListNode *temp = cur;
                cur = cur->next;
                temp->next = font->next;
                font->next = temp;
            }
            else if (number < left)
            {
                font = cur;
                cur = cur->next;
            }
            else
            {
                break;
            }
        }
        rear->next = cur;
        return h->next;
    }
};