Java单边表的局部翻转

反转链表 II

这是上一个翻转全部链表的进阶版，大家可以先去看我的上一篇博客

Java算法之单链表的全部翻转-CSDN博客

题目描述

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

示例1：

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

 示例2：

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

 方案一：两次遍历

这里需要调用上面提到的翻转全部链表的函数，这里就直接拿过来了如下：

    public ListNode reverseList1(ListNode head) {
        //指向需要改变指向节点的前一个结点
        //头节点的前一个节为null
        ListNode pre = null;
        //指向需要改变指向的节点
        ListNode cur = head;
        while(cur != null){//这个条件确保所有的节点全部调转指向
            ListNode temp = cur.next;
            //调转当前节点的指向
            cur.next = pre;
            //将两个指针全部后移一位
            pre = cur;
            cur = temp;
        }
        //最终cur指向了null
        //pre指向了原链表的最后一个节点也就是反转后列表的头节点
        return pre;
    }

这个函数的作用就是，传递一个链表的头结点，然后就可以将整条链表翻转

        这样看的话局部翻转的题目就可以分成三部分，除了中间红框圈起来的需要翻转部分，还剩下左边和右边的不需要反转的部分，那么这个题目就可以这样解：

通过遍历获取到left节点的前一个节点，和right节点的后一个节点，并且让right节点暂时指向null，并且创建一个新的引用newHead让它指向left节点。调用上面的reverseList1函数 ，参数就放newhead,这样一来,我们就得到了一条反转后的链表. 

        然后让左边部分的最后一个节点指向反转后链表的头节点也就是right节点,让反转后的尾节点指向右边第一个节点。

    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 curr = rightNode.next;

        // 注意：切断链接
        pre.next = null;
        rightNode.next = null;

        // 调用完全反转函数
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre.next = rightNode;
        leftNode.next = curr;
        return dummyNode.next;
    }

方案二：一次遍历

        那么有没有什么办法可以只通过一次遍历就完成局部反转链表的功能呢？其实是有的，根据上面的思路，我们清楚了要想完成局部翻转，不仅需要完成局部翻转还需要让整条链表连接起来，所以我们需要在完成反转的同时，记录下几个重要的节点：

        1.是left节点和left节点的前一个节点

        2.是right节点和right节点的下一个节点

看过我上一篇实现链表完全翻转的博客的同学应该应该还记得，我们完成链表反转后，per指针指向的就是链表最后一个节点，而cur指向的就是per的下一个节点，如果将这个需要翻转部分的链表当做是上一篇博客中需要完全翻转的链表的话，当翻转完成时，per指向的就是right节点，cur就是指向了right的下一节点。

而left节点和left的前一节点也可以在同一次遍历中获得，然后只需让left的前一节点指向pre指向的节点，left节点指向cur指向的节点就可以了。

这时我们不得不考虑一下left为第一个节点的情况，这样就不会有left的前一节点，为了避免这种分情况讨论的麻烦，我们创建了一个哑结点（不存储任何数据），让它的next域指向头结点，这样一来，无论如何left节点总会有前一节点。

        ListNode dunnmy = new  ListNode();
        dunnmy.next = head;

 初始状态

 假设left值为2，right值为4，找到left节点，并用p0指针记录left的前一节点的位置

反转完成后

我们可以看到per向后移动了3个节点，所以迭代次数为right-left+1次

p0的next域指向了left节点

最终

        p0.next.next = cur;
        p0.next = pre;

 拉直后

    //反转两个节点及其中间的节点
    public ListNode reverseBetween(ListNode head, int left, int right) {

        ListNode dunnmy = new  ListNode();
        dunnmy.next = head;
        //保存下需要反转的节点的前一个节点
        //反转节点
        //将反转后节点指向后一节点
        ListNode pre = null;
        ListNode cur = dunnmy;
        ListNode p0;//用来存储left的前一节点
        for(int i=0;i<left;i++){
            pre = cur;
            cur = cur.next;
        }
        p0 = pre;
        pre = null;
        for(int i=0;i<right-left+1;i++){//总共需要反转的链条数量是right-left+1,包括让left节点暂时指向null
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        //现在pre指向的是right节点,cur指向的是right的下一节点
        //p0.next.next就是left节点的next域
        p0.next.next = cur;
        p0.next = pre;
        return dunnmy.next;
    }