【细节】反转链表

反转链表1：力扣反转链表1

提前获知：

1. 需要三个指针：curr指向当前结点，currPre指向当前结点的前一个结点，currAfter指向当前结点的后一个结点
2. 起始条件：curr指向第一个结点，currPre指向null，currAfter指向curr.next
3. 终止条件：curr指向了最后一个结点的下一个，即null
4. 如果不改变currAfter执行位置，最后一次会报空指针异常，所以每次反转前记录当前结点的下一个位置即可

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode currPre = null;
        ListNode curr = head;
        while (curr != null) {
            ListNode currAfter = curr.next;
            curr.next = currPre ;
            currPre = curr;
            curr = currAfter;
        }
        return currPre;
    }
}

反转链表2：反转链表2

提前获知：

1. 反转链表2，包含了，反转链表1
2. 需要知道子链表的前一个结点 和 子链表的后一个结点
3. 使用一个伪头结点

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
    	ListNode hair = new ListNode();
    	hair.next = head;
    	
    	ListNode pre = hair;
    	for(int i = 1; i < left; i++) {
    		pre = pre.next;
    	}
    	
    	ListNode tail = hair;
    	for(int i = 0; i <= right; i++ ) {
    		tail = tail.next;
    	}
    	
    	ListNode currPre = tail;
    	ListNode curr = pre.next;
    
    	while(curr != tail) {
            ListNode currAfter = curr.next;
    		curr.next = currPre;
    		currPre = curr;
		    curr = currAfter;
    	}

    	pre.next = currPre;
    	
    	return hair.next;
    	
    }
}

执行用时：0 ms, 在所有 Java 提交中击败了100.00%的用户

内存消耗：35.9 MB, 在所有 Java 提交中击败了69.49%的用户

通过测试用例：44 / 44