单链表——翻转链表

1 翻转链表

1.1 题目描述

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

数据范围： 0\leq n\leq10000≤n≤1000
要求：空间复杂度 O(1)O(1) ，时间复杂度 O(n)O(n) 。

如当输入链表{1,2,3}时，
经反转后，原链表变为{3,2,1}，所以对应的输出为{3,2,1}。

1.2 题解

构造一个新头结点，依次将原来的节点插入新头结点和第二个结点之间

public ListNode ReverseList(ListNode head) {
    if(head == null) {
        return head;
    }

    ListNode newHead = new ListNode(-1);
    ListNode cur = head;
    while(cur != null) {
        ListNode nextNode = cur.next;
        cur.next = newHead.next;
        newHead.next = cur;
        cur = nextNode;
    }
    return newHead.next;
}

2 翻转部分链表

2.1 题目描述

BM2 链表内指定区间反转
描述
将一个节点数为 size 链表 m 位置到 n 位置之间的区间反转，要求时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)。
例如：
给出的链表为 1\to 2 \to 3 \to 4 \to 5 \to NULL1→2→3→4→5→NULL, m=2,n=4m=2,n=4,
返回 1\to 4\to 3\to 2\to 5\to NULL1→4→3→2→5→NULL.

数据范围： 链表长度 0 < size \le 10000<size≤1000，0 < m \le n \le size0<m≤n≤size，链表中每个节点的值满足 |val| \le 1000∣val∣≤1000
要求：时间复杂度 O(n)O(n) ，空间复杂度 O(n)O(n)
进阶：时间复杂度 O(n)O(n)，空间复杂度 O(1)O(1)

输入：
{1,2,3,4,5},2,4
返回值：
{1,4,3,2,5}

输入：
{5},1,1
返回值：
{5}

2.2 题解

先遍历到需要反转的子链表之前，然后依次插入后面链表指定的节点。
核心代码

public ListNode reverseBetween (ListNode head, int m, int n) {
    // write code here
    ListNode newHead = new ListNode(-1);
    newHead.next = head;
    ListNode pre = newHead;
    //遍历m-1次，遍历到需要反转的子链表之前的一个节点
    for(int i=0;i<m-1;i++) {
        pre = pre.next;
    }

    ListNode cur = pre.next; // 从需要反转的第一个节点开始
    for(int i=0;i<n-m;i++) { //翻转的次数为翻转节点个数减一
    	// 翻转逻辑，依次将cur的后面一个插入pre和cur中间
        ListNode nextNode = cur.next; 
        cur.next = nextNode.next;
        nextNode.next = pre.next;
        pre.next = nextNode;
    }
    return newHead.next;
}

3 每K个一组翻转

3.1 题目描述

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

数据范围： \ 0 \le n \le 2000 0≤n≤2000 ， 1 \le k \le 20001≤k≤2000 ，链表中每个元素都满足 0 \le val \le 10000≤val≤1000
要求空间复杂度 O(1)O(1)，时间复杂度 O(n)O(n)
例如：
给定的链表是 1\to2\to3\to4\to51→2→3→4→5
对于 k = 2k=2 , 你应该返回 2\to 1\to 4\to 3\to 52→1→4→3→5
对于 k = 3k=3 , 你应该返回 3\to2 \to1 \to 4\to 53→2→1→4→5

3.2 题解

使用递归求解，每一组翻转后求剩下的链表的结果。
每一组的翻转采用倒序的方式，pre指向null，然后依次往前插入，最终pre指向头节点，head指向尾节点，tail是一个链表的结尾后一个，也是新链表的开头。

public ListNode reverseKGroup (ListNode head, int k) {
    // write code here
    ListNode tail = head;
    for(int i=0; i<k; i++) { //找到k个，不够则返回，够则将tail指向下一组的开头
        if(tail == null) {
            return head;
        }
        tail = tail.next;
    }

    ListNode cur = head;
    ListNode pre = null;
    while (cur != tail) { //依次倒序
        ListNode nextNode = cur.next;
        cur.next = pre;
        pre = cur;
        cur = nextNode;
    }

    head.next = reverseKGroup(tail,k); //递归
    return pre;
}