单链表反转功能java实现

/**
 * 单链表反转
 */
public class SingleListReverseDemo {
    public static void main(String[] args) {
        SingleListReverse singleListReverse = new SingleListReverse();
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(5);
        Node node4 = new Node(8);
        Node node5 = new Node(0);
        singleListReverse.addNode(node1);
        singleListReverse.addNode(node2);
        singleListReverse.addNode(node3);
        singleListReverse.addNode(node4);
        singleListReverse.addNode(node5);
        singleListReverse.showList();
        System.out.println("链表反转================");
        singleListReverse.reverseList();
        singleListReverse.showList();
    }
}


/**
 * 定义节点，
 */
class Node {

    /**
     * 数据
     */
    public int data;

    /**
     * 下一个节点
     */
    public Node next;

    /**
     * 构造函数
     *
     * @param data
     */
    public Node(int data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "Node{" +
                "data=" + data +
                '}';
    }
}

/**
 * 链表操作节点
 */
class SingleListReverse {
    /**
     * 默认有个头节点，不参与任何增删改查操作
     */
    private Node head = new Node(0);

    /**
     * 增加节点
     *
     * @param node
     */
    public void addNode(Node node) {
        // 定义一个指针
        Node temp = head;
        // 指针后移找到尾节点
        while (temp.next != null) {
            temp = temp.next;
        }
        temp.next = node;
    }

    /**
     * 顺序打印节点数据
     */
    public void showList() {
        // 无数据
        if (head.next == null) {
            System.out.println("链表为空~");
            return;
        }
        // 定义一个指针
        Node temp = head.next;
        // 打印数据且指针后移
        while (null != temp) {
            System.out.println(temp);
            temp = temp.next;
        }
    }

    /**
     * 链表反转
     */
    public void reverseList() {
        // 链表为空或者只有一个数据，无需反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        // 原链表指针
        Node temp = head.next;
        // 反转链表的头节点
        Node reverseHead = new Node(0);
        // 辅助节点，记录temp下一个节点
        Node next = null;
        while (temp != null) {
            // 记录下原链表指针下一节点，防止指针丢失
            next = temp.next;
            // 取到的节点置于反转链表表头和其下一个节点之间，只有头结点的时候，取到的节点指向null
            temp.next = reverseHead.next;
            reverseHead.next = temp;
            // 原链表指针后移
            temp = next;
        }
        // 反转链表完成
        head.next = reverseHead.next;
    }
}