BM2 链表内指定区间反转

BM2 链表内指定区间反转

描述

将一个节点数为 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≤10000<size≤1000，0<m≤n≤size0<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}

代码

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

思路：将角标m到n的区域链表，单独抽出一个方法做简单的链表反转，反转后的链表再连接到原链表中即可。

一、双链表（O(n)）

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param m int整型 
     * @param n int整型 
     * @return ListNode类
     */
    public ListNode reverseBetween (ListNode head, int m, int n) {
        if(m==1) return reverseByDoubleList(head,n,1);
        if(m==n) return head;
        int i = 1;
        ListNode p = head;
        while(p!=null){
            if(i==m-1){
                p.next = reverseByDoubleList(p.next,n,m);
                return head;
            }
            p = p.next;
            i++;
        }
        return head;
    }

    //双链表方法(O(n))
    public ListNode reverseByDoubleList(ListNode node,int n,int i){
        ListNode newNode = null;
        ListNode end = node;
        while(node!=null && i<=n){
            ListNode temp = node.next;
            node.next = newNode;
            newNode = node;
            node = temp;
            i++;
        }
        end.next = node;
        return newNode;
    }
}

二、堆栈方法（O(n)）

public class Solution {
    public ListNode reverseBetween (ListNode head, int m, int n) {
        if(m==n) return head;
        if(m==1) return reverseByStack(head,n,1);
        int i = 1;
        ListNode p = head;
        while(p!=null){
            if(i==m-1){
                p.next = reverseByStack(p.next,n,m);
                return head;
            }
            p = p.next;
            i++;
        }
        return head;
    }
    // //堆栈方法
    public ListNode reverseByStack(ListNode node,int n,int i){
        Stack<ListNode> stack = new Stack<ListNode>();
        while(node!=null && i<=n){
            stack.push(node);
            i++;
            node = node.next;
        }
        if(stack.isEmpty()) return null;
        ListNode end = node;
        ListNode newNode = stack.pop();
        ListNode p = newNode;
        while(!stack.isEmpty()){
            newNode.next = stack.pop();
            newNode = newNode.next;
        }
        newNode.next = end;
        return p;
    }
}

三、迭代方法（进阶O(1)）

public class Solution {
    public ListNode reverseBetween (ListNode head, int m, int n) {
        if(m==n) return head;
        if(m==1) return reverseByDiedai(head,n,1);
        int i = 1;
        ListNode p = head;
        while(p!=null){
            if(i==m-1){
                p.next = reverseByDiedai(p.next,n,m);
                return head;
            }
            p = p.next;
            i++;
        }
        return head;
    }
    //逆转链表 迭代方法
    public ListNode reverseByDiedai(ListNode node,int n,int i){
        ListNode pre = null;
        ListNode newNode = node;
        while(newNode!=null && i<=n){
            ListNode temp = newNode.next;
            newNode.next = pre;
            pre = newNode;
            newNode = temp;
            i++;
        }
        if(newNode!=null) node.next = newNode;
        return pre;
    }
}

…递归方法尝试失败