链表之指定区间反转

描述

将一个节点数为 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}

基本思路：

1.遍历整个链表

2.将从第m个结点开始到第n个结点的结点都倒置

既然要倒置从m到n的结点，所以可以想到之前的链表之反转链表

这里有个疑问：如果正好从第一个开始倒置怎么办？

当时我没注意到这个点，所以写完后发现，有例子出错了。那么如果我们想要保证原来的链表的任何位置都保持相同处理逻辑，那么最好引入一个头结点

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     *
     * @param head ListNode类
     * @param m int整型
     * @param n int整型
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
         //1.判空或只有一个结点
        if (head == null || head.next == null) {
            return head;
        }

        //2.需要设置一个头结点 (非常重要)
        ListNode dummyNode = new ListNode(0);
        dummyNode.next = head;

        ListNode leftNode = null;
        ListNode rightNode = null;
        ListNode preNode = null;
        ListNode curNode = dummyNode;
        int location = 0;
        //3.找到需要反转的结点的头和尾
        while (curNode != null) {
            if (location == m - 1) {
                preNode = curNode;
            }
            if (location == m) {
                leftNode = curNode;
            }
            if (location == n) {
                rightNode = curNode;
            }
            // 在第n个结点的后一个位置,进行调整
            if (location == n + 1) {
                break;
            }
            location++;
            curNode = curNode.next;
        }
        //4.切断反转链表的对前后的连接
        preNode.next = null;
        rightNode.next = null;

        //5.反转m到n个结点
        preNode.next = reverse(leftNode);
        leftNode.next = curNode;

        return dummyNode.next;
    }

    public ListNode reverse(ListNode head) {
        ListNode newHead = null;
        ListNode cur = head;
        ListNode next = null;
        while (cur != null) {
            System.out.println("curNode = " + cur.val);
            //先定位到下一个节点的位置
            next = cur.next;
            //将当前节点的下一个节点指向新链表的表头
            cur.next = newHead;
            //再将新链表的表头重新定位到当前节点
            //此时已经实现的当前结点指向前一个节点的操作
            newHead = cur;
            //将当前结点指向下一个节点，为下一次循环作准备
            cur = next;
        }
        return newHead;
    }
}

是否还能再简约一些呢？

import java.util.*;
 
/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */
 
public class Solution {
    /**
     *
     * @param head ListNode类
     * @param m int整型
     * @param n int整型
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
        //1.设置虚拟头节点
        ListNode dummy =new ListNode(0);
        dummy.next=head;
        ListNode pre=dummy;
        //2.将pre指针移动到m前一个位置
        for(int i=0;i<m-1;i++){
            pre=pre.next;
        }
        //3.获取m位置
        ListNode cur=pre.next;
        ListNode next;
        for(int i=0;i<n-m;i++){
            next=cur.next;
            cur.next=next.next;
            //注意这里不能是next.next=cur,因为cur一直指的是最开始时m位置的节点
            next.next=pre.next;
            pre.next=next;
        }
        return dummy.next;
 
    }
}