算法通关村第二关-指定区间（两两）反转问题解析

1、指定区间反转

在上期我们已经讲过了链表的反转问题，今天我们要进一步讨论的是指定区间链表的反转问题。

输入：

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

如果你在上一期已经完全掌握了头插法和穿针引线法，那么这种问题自然就很容易解决。

我这边就直接使用穿针引线法来解决。

需要哪些节点信息？

如上图，起始反转节点的前一个节点，起始反转的节点，终止反转的节点，终止节点的下一个节点。

步骤：

1. 找到起始反转节点的前节点并进行保存，将待反转的区域进行反转，保存终止节点的下一个节点。
2. 把perv的next指针指向反转以后的链表的头结点，把反转以后的链表的尾节点的next指针指向succ。

代码：

public static Node reserveOne(Node head, int left, int right) {
        if (head == null || right > length(head)) {
            return head;
        }
        Node dumNode = new Node(0);
        dumNode.next = head;
        Node leftOut = dumNode;
        //找到起始节点的前一个节点leftOut并保存
        for (int i = 0; i < left-1; i++) {
            leftOut = leftOut.next;
        }
        Node prev = null;
        Node curr = leftOut.next;
        Node leftIn = curr;
        System.out.println(leftIn.val);
        //开始反转  反转的次数为right - left +1
        for (int i = 0; i <= right-left; i++) {
            Node node = curr.next;
            curr.next = prev;
            prev = curr;
            curr = node;
        }
        //将起始节点的前一个节点leftOut的下一个节点指向反转后的头结点prev
        leftOut.next = prev;
        //将反转后的最后一个节点（起始节点）指向当前节点
        leftIn.next = curr;
        return dumNode.next;
    }

2、 两两反转（特例）

实例：

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

接下来我们来看一种特殊情况，两两反转，相邻的节点进行反转。当然可以用指定区间的方法进行解决。但是每次都要输入两个位置，麻烦呀！下面我介绍两种简单的方法！

2.1直接反转

步骤：

1. 先保存两个节点的信息。
2. 点前节点的下一个节点指向第二个节点。
3. 第一个节点的下一个节点指向第二个节点的下一个节点。
4. 第二个节点的下一个节点指向第一个节点。

注：3必须在4前面！！

代码：

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

2.2递归

假设我们k前面的都已经反转完成。那我们就只需要反转接下来的两个节点。 

步骤： 

1. 先保存两个节点的信息。
2. 点前节点的下一个节点指向第二个节点。
3. 第一个节点的下一个节点指向第二个节点的下一个节点。
4. 第二个节点的下一个节点指向第一个节点。

其实这个方法和之前的方法差不多，唯一的区别就是，我们的second.next的获取方式不同，之前我们是通过保存来获取的，现在我们要通过传入second.next来得到反转后的头结点，而我们现在first.next的值就是以second.next为头的两个节点反转后的返回值。（有点难理解，递归都是这个样子，做得多了，就很清楚了）

代码：

    public static ListNode swap(ListNode head) {
        ListNode prev = new ListNode(0);
        prev.next = head;
        ListNode cur = prev;
        if (cur.next != null && cur.next.next != null) {
            ListNode first = cur.next;
            ListNode second = cur.next.next;
            cur.next = second;
            first.next = swap(second.next);
            second.next = first;
        }
        return prev.next;
    }