剑指offer-反转链表

public class Test {
    
    class ListNode {
        int value;
        ListNode next;
        public ListNode(int value) {
            this.value = value;
        }
    }
    
    public static void main(String[] args) {
        Test t = new Test();
        ListNode node1 = t.new ListNode(1);
        ListNode node2 = t.new ListNode(2);
        ListNode node3 = t.new ListNode(3);
        ListNode node4 = t.new ListNode(4);
        ListNode node5 = t.new ListNode(5);
        ListNode node6 = t.new ListNode(6);
        ListNode node7 = t.new ListNode(7);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        node7.next = null;
        ListNode reverse = t.reverseList(node1);
        while(reverse != null) {
            System.out.println(reverse.value);  // 打印反转链表
            reverse = reverse.next;
        }
    }    
    
    /**
     * 在调整当前处理结点的下一结点之前，将当前处理结点的下一结点保存。
     * 也就是需要三个指针，分别指向当前结点的前驱结点、当前节点和后一结点
     * @param head
     * @return
     */
    public ListNode reverseList(ListNode head) {
        if(head == null) return null;
        
        // 用于记录反转后的链表的头结点
        ListNode reverseNode = null;
        
        // 当前结点的前驱结点，也就是反转后的最后一个结点的下一结点，为null
        ListNode prev = null;
        
        // 当前处理的节点
        ListNode curr = head;
        while(curr != null) {
            
            // 记录当前处理结点的下一结点
            ListNode nextNode = curr.next;
            // 到达最后一个结点，也就是反转后的头结点
            if(curr.next == null) {
                reverseNode = curr;
            }
            
            // 设置当前结点的下一结点指向前驱结点
            curr.next = prev;
            // 设置当前结点为前驱结点
            prev = curr;
            // 当前结点移动到下一个结点
            curr = nextNode;
        }
        
        return reverseNode;  // 返回反转链表头结点        
    }
}