206.反转列表 + 92.反转列表Ⅱ

206.反转列表

反转列表：迭代方法，比递归好，节省空间

必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

public ListNode reverseList(ListNode head){
        ListNode previous = null;
        ListNode curr = head;
        while(curr != null){
            ListNode next = curr.next;
            curr.next = previous;
            previous = curr;
            curr = next;
        }        
        return previous;
    }

• 时间复杂度：O(n)，其中 n 是链表的长度。需要遍历链表一次。

• 空间复杂度：O(1)

92反转列表Ⅱ

①找到第一个left所在结点的前一个结点pre并断开——让pre.next = null

②找到第二个rght所在结点的后一个结点next并断开——让now.next = null

③反转链表，并返回反转后链表的头结点newHead

④重新接上反转的链表

class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if(left == right){
            return head;
        }
        //结点now是当前所指向的结点；pre要赋初值，不然left=1时候pre无值；next为right后面第一个结点
        ListNode now = head,pre = now,next = null;
        int flag = 1;

        //找到left前一个截断，设定为pre
        while(flag != left){
            pre = now;
            now = now.next;
            flag++;
        }

        //找到right后一个截断,为next
        while(flag != right){
            now = now.next;      
            flag++;
        }
       //当前now是right位置结点
        next = now.next;        //next的后一个
        now.next = null;
        ListNode newHead = null;

        //如果从第一个开始反转就走if语句第一个
        if(left != 1){
            newHead = reverseLink(pre.next);
            pre.next = newHead;
            while(pre.next != null){
                pre = pre.next;
            }
            pre.next = next;
            return head;
        }else{
            newHead = reverseLink(pre);
            head = newHead;
            while(newHead.next != null){
                newHead = newHead.next;
            }
            newHead.next = next;
            return head;
        }
    }

    //206.反转链表
    public ListNode reverseLink(ListNode head){
        ListNode pre = null;
        ListNode now = head;
        ListNode newHead = null;
        while(now != null){
            newHead = now;
            ListNode next = now.next;
            now.next = pre;
            pre = now;
            now = next;
        }
        return newHead;
    }
}

• 时间复杂度：O(N)，其中 N是链表总节点数。

• 空间复杂度：O(1)。