2.2 链表反转扩展问题

1.指定区间反转

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

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

这里的处理方式也有很多种，甚至给个名字都有点困难，干脆就叫穿针引线法和头插法吧。穿针引线本质上就是不带有结点的方式来实现反转，而头插法本质上就是带头结点的反转。

1.1 头插法

方法1的缺点是：如果 left 和 right 的区域很大，恰好是链表的头结点和尾结点时，找到 left 和 right 需要遍历一次，反转它们之间的链表还需要遍历一次，虽然总的时间复杂度为 O(n)，但遍历了链表两次，可不可以只遍历一次呢？答案是可以的。我们依然画图进行说明，我们仍然以方法1的序列为例进行说明。

反转的整体思想是，在需要反转的区间里，每遍历到一个结点，让这个新结点来到反转部分的起始位置。下面的图展示了整个流程。

这个过程就是前面的带虚拟结点的插入操作，每走一步都要考虑各种指针怎么指，既要将结点摘下来接到对应的位置上，还要保证后继结点能够找到，请读者务必画图看一看，想一想到底该怎么调整。
代码如下：

public ListNode reverseBetween(ListNode head, int left, int right) {
    // 设置 dummyNode 是这一类问题的一般做法
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
    ListNode pre = dummyNode;
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
    ListNode cur = pre.next;
    ListNode next;
    for (int i = 0; i < right - left; i++) {
        next = cur.next;
        cur.next = next.next;
        next.next = pre.next;
        pre.next = next;
    }
    return dummyNode.next;
}

代码图解：

1.2 穿针引线法

这种方式能够复用我们前面讲的链表反转方法，但是实现难度仍然比较高一些。我们以反转下图中蓝色区域的链表反转为例：

我们可以这样做：先确定好需要反转的部分，也就是下图的 left 到 right 之间，然后再将三段链表拼接起来。这种方式类似裁缝一样，找准位置减下来，再缝回去。这样问题就变成了如何标记下图四个位置，以及如何反转 left 到 right 之间的链表。

算法步骤：

• 第 1 步：先将待反转的区域反转；
• 第 2 步：把 pre 的 next 指针指向反转以后的链表头节点，把反转以后的链表的尾结点的 next 指针指向 succ。
  
  编码细节我们直接看下方代码。思路想明白以后，编码不是一件很难的事情。这里要提醒大家的是，链表什么时候切断，什么时候补上去，先后顺序一定要想清楚，如果想不清楚，可以在纸上模拟，思路清晰。
  代码如下：

public ListNode reverseBetween(ListNode head, int left, int right) {
    // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
    ListNode dummyNode = new ListNode(-1);
    dummyNode.next = head;
    ListNode pre = dummyNode;
    // 第 1 步：从虚拟头节点走 left-1 步，来到 left 节点的前一个节点
    // 建议写在 for 循环里，语义清晰
    for (int i = 0; i < left - 1; i++) {
        pre = pre.next;
    }
    // 第 2 步：从 pre 再走 right-left+1 步，来到 right 节点
    ListNode rightNode = pre;
    for (int i = 0; i < right - left + 1; i++) {
        rightNode = rightNode.next;
    }
    // 第 3 步：切出一个子链表
    ListNode leftNode = pre.next;
    ListNode succ = rightNode.next;
    // 思考一下，如果这里不设置 next 为 null 会怎样
    rightNode.next = null;
    // 第 4 步：同第 206 题，反转链表的子区间
    reverseLinkedList(leftNode);
    // 第 5 步：接回到原来的链表中
    // 想一下，这里为什么可以用 rightNode
    pre.next = rightNode;
    leftNode.next = succ;
    return dummyNode.next;
}

private void reverseLinkedList(ListNode head) {
    // 也可以使用递归反转一个链表
    ListNode pre = null;
    ListNode cur = head;
    while (cur != null) {
        ListNode next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
}

代码图解：

2.两两交换链表中的节点

这是一道非常重要的问题，读者务必理解清楚。
LeetCode 24
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部值的情况下完成本题（即，只能进行节点交换）。

如果要解决此问题，将上面小节的K换成2不就是这个题吗？道理确实如此，但是如果K为2的时候，可以不需要像K个一样需要先遍历找到区间的两端，而是直接取前后两个就行了，因此基于相邻结点的特性重新设计和实现就行，不需要上面这么复杂的操作。
如果原始顺序是 dummy => node1 => node2，交换后面两个节点关系要变成 dummy => node2 => node1，事实上我们只要多执行一次next就可以拿到后面的元素，也就是类似 node2=temp.next.next 这样的操作。
两两交换链表中的节点之后，新的链表的头节点是 dummyHead.next，返回新的链表的头节点即可。指针的调整可以参考如下图示：

完整代码：

public static ListNode swapPairs(ListNode head) {
    ListNode dummyHead = new ListNode(0);
    dummyHead.next = head;
    ListNode temp = dummyHead;
    while (temp.next != null && temp.next.next != null) {
        ListNode node1 = temp.next;
        ListNode node2 = temp.next.next;
        temp.next = node2;
        node1.next = node2.next;
        node2.next = node1;
        temp = node1;
    }
    return dummyHead.next;
}

代码图解：

3.单链表加1

LeetCode369
用一个非空单链表来表示一个非负整数，然后将这个整数加一。你可以假设这个整数除了 0 本身，没有任何的前导 0。这个整数的各个数位按照 高位在链表头部、低位在链表尾部 的顺序排列。

示例：
输入：[1,2,3]
输出：[1,2,4]

我们先看一下加法的计算过程：
计算是从低位开始的，而链表是从高位开始的，所以要处理就必须反转过来，此时可以使用栈，也可以使用链表反转来实现。
基于栈实现的思路不算复杂，先把题目给出的链表遍历到栈中，然后从栈中弹出栈顶数字 digit，加的时候再考虑一下进位的情况就ok了，加完之后根据是否大于10决定视为下一次要进位。

public static ListNode plusOne(ListNode head) {
    Stack<Integer> st = new Stack<>();
    while (head != null) {
        st.push(head.val);
        head = head.next;
    }
    int carry = 0;
    ListNode dummy = new ListNode(0);
    int adder = 1;
    while (!st.empty() || carry > 0) {
        int digit = st.empty() ? 0 : st.pop();
        int sum = digit + adder + carry;
        carry = sum >= 10 ? 1 : 0;          // 1    // 0     // 0
        sum = sum >= 10 ? sum - 10 : sum;   // 0    // 3     // 1
        ListNode cur = new ListNode(sum);   // 0    // 3     // 1
        cur.next = dummy.next;              // 0    // 3 0   // 1 3 0
        dummy.next = cur;                   // 0 0  // 0 3 0 // 0 1 3 0
        adder = 0;
    }
    return dummy.next;
}

上面的代码，我们简单解释一下，carry的功能是记录进位的，相对好理解。
那这里的adder是做什么的？很多人会感到困惑，这个主要表示就是需要加的数1，也就是为了满足单位链表加1的功能，那这里能否直接使用1，而不再定义变量呢？也就是将上面的while循环改成这样子：

while (!st.empty() || carry > 0) {
    int digit = st.empty() ? 0 : st.pop();
    int sum = digit + 1 + carry;
    carry = sum >= 10 ? 1 : 0;
    sum = sum >= 10 ? sum - 10 : sum;
    ListNode cur = new ListNode(sum);
    cur.next = dummy.next;
    dummy.next = cur;
}

很遗憾，这样是不行的，会将我们每个位置都加1，例如，如果原始单链表是 {7,8} 这里就会将其变成 {8,9}，而不是我们要的 {7,9}，导致这样的原因是循环处理链表每个结点元素的时候 sum=digit+1+carry 这一行会将每个位置都多加了一个 1，所以我们要使用变量 adder，只有第一次是加了1，之后该变量变成0了，就不会影响我们后继运算。

4.链表加法

相加链表是基于链表构造的一种特殊题，反转只是其中的一部分。这个题还存在进位等的问题，因此看似简单，但是手写成功并不容易。
LeetCode 445
给你两个非空链表来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两个数字相加会返回一个新的链表。你可以假设除了数字 0 之外，这两个数字都不会以 0 开头。
示例：

输入：l1 = [7,2,4,3], l2 = [5,6,4]
输出：[7,8,0,7]

这个题目的难点在于存放是从最高位向最低位开始的，但是因为低位会产生进位的问题，计算的时候必须从最低位开始。所以我们必须想办法将链表节点的元素反转过来。
怎么反转呢？栈和链表反转都可以，两种方式我们都看一下。

（1）使用栈实现

思路是先将两个链表的元素分别压栈，然后再一起出栈，将两个结果分别计算。之后对计算结果取模，模数保存到新的链表中，进位保存到下一轮。完成之后再进行一次反转就行了。
我们知道在链表插入有头插法和尾插法两种。头插法就是每次将结点插入到head之前。而尾插法就是将结点都插入到链表的表尾。两者的区别是尾插法的顺序和原始链表是一致的，而头插法与原始链表是逆序的，所以上面最后一步如果不想进行反转，可以将新结点以头插法。

public static ListNode addInListByStack(ListNode head1, ListNode head2) {
    Stack<ListNode> st1 = new Stack<>();
    Stack<ListNode> st2 = new Stack<>();
    while (head1 != null) {
        st1.push(head1);
        head1 = head1.next;
    }
    while (head2 != null) {
        st2.push(head2);
        head2 = head2.next;
    }
    ListNode newHead = new ListNode(-1);
    int carry = 0;
    // 这里设置 carry!= 0, 是因为当 st1,st2 都遍历完时, 如果 carry=0, 就不需要进入循环了
    while (!st1.empty() || !st2.empty() || carry != 0) {
        ListNode a = new ListNode(0);
        ListNode b = new ListNode(0);
        if (!st1.empty()) {
            a = st1.pop();
        }
        if (!st2.empty()) {
            b = st2.pop();
        }
        // 每次的和应该是对应位相加再加上进位
        int get_sum = a.val + b.val + carry;
        // 对累加的结果取余
        int ans = get_sum % 10;
        // 如果大于0,就进位
        carry = get_sum / 10;
        ListNode cur = new ListNode(ans);
        cur.next = newHead.next;
        // 每次把最新得到的节点更新到 newHead.next 中
        newHead.next = cur;
    }
    return newHead.next;
}

（2）使用链表反转事项
如果使用链表反转，先将两个链表分别反转，最后计算完之后再将结果反转，一共有三次反转操作，所以必然将反转抽取出一个方法比较好，代码如下：

public static ListNode addInList(ListNode head1, ListNode head2) {
    head1 = reverse(head1); // 3 4 2 7
    head2 = reverse(head2); // 4 6 5
    ListNode head = new ListNode(-1); // -1
    ListNode cur = head;    // -1
    int carry = 0;
    while (head1 != null || head2 != null) {
        int val = carry;
        if (head1 != null) {
            val += head1.val;
            head1 = head1.next;
        }
        if (head2 != null) {
            val += head2.val;
            head2 = head2.next;
        }
        cur.next = new ListNode(val % 10);     // 7    // 7 0  // 0 8  // 8 7 => // 7 0 8 7
        carry = val / 10;                      // 0    // 1    // 0    // 0
        cur = cur.next;                        // 7    // 0    // 8    // 7
    }
    if (carry > 0) {
        cur.next = new ListNode(carry);
    }
    return reverse(head.next); // 7 8 0 7
}

private static ListNode reverse(ListNode head) {
    ListNode cur = head;
    ListNode pre = null;
    while (cur != null) {
        ListNode temp = cur.next;
        cur.next = pre;
        pre = cur;
        cur = temp;
    }
    return pre;
}

上面我们直接调用了反转函数，这样代码写起来就容易很多，如果你没手写过反转，所有功能都是在一个方法里，那复杂度要高好几个数量级，甚至自己都搞不清楚了。既然加法可以，那如果是减法呢？读者可以自己想想该怎么处理。

5.再论链表的回文序列问题

在上一关介绍链表回文串的时候，我们介绍的是基于栈的，相对来说比较好理解，但是除此之外还有可以使用链表反转来进行，而且可以只反转一半链表，这种方式节省空间。我们姑且称之为 “快慢指针 + 一半反转” 法。
这个实现略有难度，主要是在 while 循环中 pre.next = prepre 和 prepre = pre 两行实现了一边遍历一边将访问过的链表给反转了，所以理解起来有些难度，如果不理解可以在学完链表反转之后再看这个问题。
完整代码：

public static boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
        return true;
    }
    ListNode slow = head, fast = head;
    ListNode pre = head, prepre = null;
    while (fast != null && fast.next != null) { // 1 2 2 1 => 2 1 2 1
        pre = slow;             // 1 2 2 1  // 2 2 1
        slow = slow.next;       // 2 2 1    // 2 1
        fast = fast.next.next;  // 2 1      // null
        // 将前半部分链表反转      
        pre.next = prepre;      // 1        // 2 1
        prepre = pre;           // 1        // 2 1
    }
    if (fast != null) {
        slow = slow.next;
    }
    while (pre != null && slow != null) {
        if (pre.val != slow.val) {
            return false;
        }
        pre = pre.next;
        slow = slow.next;
    }
    return true;
}