单链表反转Java版

public static class Node{
    private int data;
    private Node next;

    public Node(int data, Node next) {
        this.data = data;
        this.next = next;
    }

    public int getData() {
        return data;
    }

    public void setNext(Node next) {
         this.next = next;
    }

    public Node getNext() {
        return next;
    }
}

/**
* 输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
* @param head
* @return
*/
public static Node reverseList_head(Node head) {
    // 创建一个临时结点，当作头插法的逻辑头结点
    Node root = new Node(0, null);
    // 逻辑头结点点的下一个结点为空
    root.next = null;
    // 用于记录要处理的下一个结点
    Node next;
    // 当前处理的结点不为空
    while (head != null) {
        // 记录要处理的下一个结点
        next = head.next;
        // 当前结点的下一个结点指向逻辑头结点的下一个结点
        head.next = root.next;
        // 逻辑头结点的下一个结点指向当前处理的结点
        root.next = head;
        // 上面操作完成了一个结点的头插
        // 当前结点指向下一个要处理的结点
        head = next;
    }
    // 逻辑头结点的下一个结点就是返回后的头结点
    return root.next;
}

/**
* 定义一个函数，输入一个链表的头结点，反转该链表并输出反转后链表的头结点。
* @param list
* @return
*/
public Node reverseList(Node list){
    if (list == null || list.getNext() == null) return list;
    // 用于记录当前处理的结点的
    Node curre = list;
    // 用于记录当前结点的前驱结点
    // 前驱结点开始为null，因为反转后的最后一个结点的下一个结点，即null
    // 也是反转链表的头结点
    Node pre = null;
    // 当前结点的下一个结点
    Node next = null;
    // 对链表进行头插法操作
    while (curre!=null){
        // 记录要处理的下一个结点
        next = curre.next;
        // 当前结点的下一个结点指向前驱结点，这样当前结点就插入到了反转链表的头部
        curre.next = pre;
        // 记录当前结点为前驱结点，完成一次头插
        pre = curre;
        // 当前结点指向下一个要处理的结点
        curre = next;
    }
    return pre;
}

public Node inverseLinkList(Node list){
    if (list == null || list.next == null) return list;

    Node pre = null;
    Node curre = list;
    Node next = null;
    
    while (curre.next!=null){
        next = curre.next;
        curre.next = pre;
        pre = curre;
        curre = next;
    }
    curre.next = pre;
    return curre;
}