逆序打印单向链表

1、
遍历打印的方式的思路：head 是一个标识，head 持有的引用，为第一个节点 ，设这个节点为 p，并始终保持 p 为 head 持有的节点，当 p 拥有下一个节点 q(q ！= null)时，获取 并记录 q 的下一个节点 t，将 q 当做 p（即保证p 始终为head持有的节点），并把 q 的下一个节点设为 p （即实现逆序），并 把 t 设置为 q(实现推进)；
2、
递归打印的方式思路：当前节点如果有下一个节点，则对下一个节点操作，直到下一个节点为 null 时返回，并打印当前节点的值；

package structure.linkedList;

/**
 * 递归与遍历的方式逆序输出单向链表
 */
public class LinkedList {
    private class Node {
        private Object data;
        private Node next;

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

        private Node(Node next) {
            this.next = next;
        }

        private Node(Object data) {
            this.data = data;
        }

        private Node() {
        }

        private Object getData() {
            return data;
        }

        private void setData(Object data) {
            this.data = data;
        }

        private Node getNext() {
            return next;
        }

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

    Node head;

    Node tail;

    public LinkedList() {
        this.head = new Node();
    }

    // 向链表中添加一个元素
    public void add(Object value) {
        Node node = new Node(value);
        if (head.getNext() == null) {
            head.setNext(node);
            tail = node;
        } else {
            tail.setNext(node);
            tail = node;
        }
    }

    public void printList() {
        Node node = head;
        while ((node = node.getNext()) != null) {
            System.out.println(node.getData());
        }
        System.out.println("--end");
    }

    public void reverserByIterate() {
        iterate();
    }

    public void reverserByRecursion() {
        recursion();
    }

    /**
     * 循环改变了数据结构
     */
    private void iterate() {
        if (head.getNext() == null || head.getNext().getNext() == null) {
            return;
        }
        Node p = head.getNext();
        Node q = head.getNext().getNext();
        Node t;
        // 因为最初的p将会是最后一个
        p.setNext(null);

        while (q != null) {
            t = q.getNext();
            // 将下一个元素的next指向上一个元素
            q.setNext(p);
            // 将头部的元素指向下一个元素
            head.setNext(q);
            // 维持 p 的定义，代表着头部的下一个元素
            p = head.getNext();
            // p q 递推向下
            q = t;
        }
    }

    private void recursion() {
        __recursion(head.getNext());
    }

    /**
     * 递归没有对原数据结构进行操纵
     *
     * @param current
     */
    private void __recursion(Node current) {
        if (current == null) {
            return;
        }
        __recursion(current.getNext());
        Object data = current.getData();
        System.out.println(data);
    }

    public static void main(String[] args) {
        LinkedList linkedList1 = buildList(10);
        linkedList1.printList();
        linkedList1.reverserByIterate();
        linkedList1.printList();
        LinkedList linkedList2 = buildList(10);
        linkedList2.printList();
        linkedList2.reverserByRecursion();
    }

    static LinkedList buildList(int size) {
        LinkedList list = new LinkedList();
        size = size < 10 ? 10 : size;
        for (int i = 0; i < size; i++) {
            list.add(i);
        }
        return list;
    }

}