刷题日记-链表翻转相关问题

链表反转

描述
给定一个单链表的头结点pHead(该头节点是有值的，比如在下图，它的val是1)，长度为n，反转该链表后，返回新链表的表头。

数据范围： 0≤n≤1000
要求：空间复杂度 O(1) ，时间复杂度 O(n) 。
如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。
以上转换过程如下图所示：

示例1
输入：{1,2,3}
返回值：{3,2,1}
示例2
输入：{}返回值：{}
说明：
空链表则输出空
思路
该算法相对较简单，只需要考虑清楚指针的变换情况。经过分析，我们只需要维护三个指针即可完成整个链表反转的过程
反转后链表的起始指针pre：维护他是为了每次将一个新的节点提到前面时，其next指针可以指向该节点
当前待反转的节点指针cur：维护他是为了将其提到前面，且可获得其下一节点
当前待反转指针的后继节点next：维护他是为了在cur指向pre后可以获得原链表的下一节点
代码如下：

public ListNode ReverseList(ListNode head) {
        ListNode pre = null;
        ListNode cur = head;
        ListNode next = null;
        while(cur!=null){
            next = cur.next; 
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }

指定区间内链表反转

描述
将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)，空间复杂度 O(1)。
例如：
给出的链表为 1→2→3→4→5→NULL, m=2,n=4,
返回 1→4→3→2→5→NULL.
数据范围： 链表长度 0 <size≤1000，0<m≤n≤size，链表中每个节点的值满足 ∣val∣≤1000
要求：时间复杂度 O(n)，空间复杂度 O(n)
进阶：时间复杂度 O(n)，空间复杂度 O(1)
示例1
输入：{1,2,3,4,5},2,4
返回值：{1,4,3,2,5}
示例2
输入：{5},1,1
返回值：{5}
思路
该算法是在上述问题的基础上的延伸问题。一个简单的思路是将链表分割成三部分，对中间需要进行反转的区间调用上述链表反转函数，最后再进行拼接。这样做的话需要两次遍历，相对较复杂，因此提出一种简单的方式直接在链表内进行某一区间内反转。
首先考虑一种特殊情况：m=0时，进行完反转后，列表的头指针发生改变。为了避免对头指针进行过多无谓的讨论，引入一个虚拟头节点，之后无论后续链表怎么反转，只需要返回该虚拟头结点的next节点即可
之后维护三个变量：
last指的是翻转区间的前一个节点，该值自得到后便不再变化
first指的是翻转区间的第一个节点，该值自得到后也不再变化
cur指的是待翻转节点
整体的流程是从first的后一个节点开始，依次把cur放到last的后面
代码如下：

public ListNode reverseBetween (ListNode head, int m, int n) {
        ListNode dummyNode = new ListNode(-1);//创建虚拟头节点
        dummyNode.next = head;
        ListNode cur = null;
        ListNode last = dummyNode;
        int i=1;
        while(i<m){
            last = last.next;
            i=i+1;
        }
        ListNode first = null;
        first = last.next;
        if(first==null){
            return head;
        }
        
        int j=0;
        while(j<n-m){
            cur = first.next;
            first.next = cur.next;
            cur.next = last.next;
            last.next = cur;
            j=j+1;
        }
        return dummyNode.next;
    }

每k个一组翻转链表

描述
将给出的链表中的节点每 k 个一组翻转，返回翻转后的链表
如果链表中的节点数不是 k 的倍数，将最后剩下的节点保持原样
你不能更改节点中的值，只能更改节点本身。

数据范围：0≤n≤2000 ，1≤k≤2000 ，链表中每个元素都满足0≤val≤1000
要求空间复杂度 O(1)，时间复杂度 O(n)
例如：
给定的链表是 1→2→3→4→5
对于 k = 2, 你应该返回 2→1→4→3→5
对于 k = 3, 你应该返回 3→2→1→4→5
示例1
输入：{1,2,3,4,5},2
返回值：{2,1,4,3,5}
示例2
输入：{},1
返回值：{}
思路
非递归版：
从区间内链表翻转得到启发，实际上当前所做的也是区间内链表翻转所做的工作。只是调用n/k次区间内链表翻转函数的话最后的时间复杂度为$O(n^2)$,因此，最佳的思路是一次遍历就实现整个链表的翻转。
维护三个变量：
last指的是当前翻转区间的前一个节点
first指的是当前翻转区间的第一个节点
first和last在处理一个待翻转区间时是不发生改变的，在更换区间时，新区间的last是上一区间的first。
为什么？因为区间进行了翻转，原来区间的第一个节点变成了最后一个节点
cur指的是待翻转节点
对于该问题依旧引入一个虚拟头结点，防止对头结点的无谓讨论

 public ListNode reverseKGroup (ListNode head, int k) {
        ListNode dummy =new ListNode(-1);
        dummy.next = head;
        ListNode last = dummy;
        ListNode first = null;
        ListNode cur = null;
        ListNode ite = head;
        int length=0;
        while(ite!=null){
            ite = ite.next;
            length++;//首先遍历获得链表的长度
        }
        for(int i=0;i<length/k;i++){
            first = last.next;//first是对整个翻转区间固定的
            for(int j=1;j<k;j++){//这里j是从1开始的，因为我们是对first节点之后的节点进行提前操作
                cur = first.next;//这里的修改跟区间内翻转相同
                first.next = cur.next;
                cur.next = last.next;
                last.next = cur;
            }
            last = first;//新区间的last就是上一区间的first
        }
        return dummy.next;
    }