Leetcode刷题--链表

一、操作链表结构

1. 反转链表
   解题思路：
   三个指针：一个指针pre保存老链表的next节点，一个指针cur保存当前节点，一个指针tmp为新链表头指针。

ListNode* reverseList(ListNode* head) {
    // 3个指针, 保存老链表下一个元素，cur前元素，新链表头元素
    ListNode *next = nullptr; 
    ListNode *cur = head;
    ListNode *tmp = nullptr;
    while(cur != nullptr) {
        next = cur->next; // 断开连接，next为老链表的下一个元素
        cur->next = tmp;
        tmp = cur; 
        cur = next;
    }
    return tmp;
}

2. 反转从位置 m 到 n 的链表。请使用一趟扫描完成反转
   解题思路：待翻转元素前一个结点为top，将待翻转结点一个一个添加到top的后面，同时要保存好原来链表的下一个结点（由翻转后的结点next保存）。注意需要处理第一个元素为翻转元素的情况，通过创建第一个元素来适配这种特殊情况。

ListNode* reverseBetween(ListNode* head, int m, int n) {
    ListNode *top = new ListNode(0);
    top->next = head;
    ListNode *pre = top; // 保存原始top指针
    for (int i = 1; i < m; i++) {
        top = top->next; // 将指针移动到第一个翻转结点的前一个结点
    }
    n -= m;  // 需要翻转结点的个数-1，第一个结点不需要翻转
    ListNode *pStart = top->next; // pStart保存的是翻转后小链表的尾部结点（此时为第一个待翻转结点，第一个结点无需翻转）
    for (int i = 0; i < n; i++) { // 从第二个需要翻转的结点开始 比如[1,2,3,4] m = 2, n = 3; top=1. pStart=2
        ListNode *tmp = pStart->next; //tmp = 3 
        pStart->next = tmp->next; // 2->4
        tmp->next = top->next; // 3->2
        top->next = tmp; // 1-> 3   ==>> 1->3->2->4
    } // 始终保持两个原则：pStart指向下一个待处理元素，翻转的元素放到top后面
    return pre->next;
}

3. 旋转循环链表
   输入: 1->2->3->4->5->NULL, k = 2
   输出: 4->5->1->2->3->NULL
   解释:
   向右旋转 1 步: 5->1->2->3->4->NULL
   向右旋转 2 步: 4->5->1->2->3->NULL

思路：本质上是将尾部向前数第K个元素作为头，原来的头接到原来的尾上

ListNode* rotateRight(ListNode* head, int k) {
        // 本质上是将尾部向前数第K个元素作为头，原来的头接到原来的尾上
        // 1.收尾相连，从后往前数k个数，这个数作为头。 2. k可能大于链表长，所以可以取余
        if (head == nullptr) return head;
        ListNode *top = head;
        ListNode *lst = head;
        int count = 1;
        while(top->next) { // 循环得出链表总结点数count 和 尾元素 lst
            top = top->next;
            count++;
            lst = top;
        }
        k = k % count; // 倒数第k%count个为将来的首元素
        lst->next = head; // 收尾相连
        top = head; 
        int cycle = count - k - 1; // 移动到首元素前一个元素
        while(cycle > 0) { // 移动至未来的尾元素处，也就是将来的首元素的前一个元素
            cycle--; 
            top = top->next; 
        }
        head = top->next;
        top->next = nullptr;
        return head;
    }