题目：反向输出单向链表
解题思路：反向输出单向链表方法有很多，但笔者采用自建单向链表，自建链栈，将单向链表中元素输入栈中，再取出栈中元素，输入到新单向链表中
代码见下：

//自定义链表/链栈节点类
public class Node<T>{
    public Object  data;
    public Node next;
}

//自建单向链表
public class LinkList<T> {
    private static Node head=null;
    /**
     * 初始化
     */
    public void initLinkList(){
        head=new Node();
        head.data=null;
        head.next=null;
    }
    /**
     * 插入节点
     * @param element ：节点元素值
     */
    public void insertLinkList(T element) {
        if (element == null) {
            throw new NullPointerException("参数不能为空");
        }
        Node node = new Node(); //生成节点
        node.data = element;
        if (head.next == null) {
            head.next = node;
            node.next = null;
        } else {
            Node temp = head;
            while (temp.next != null) {
                temp = temp.next;
            }
            temp.next = node;
            node.next = null;
        }
    }
    /**
     * 值删除
     *
     * @param element : 要删除的值
     * @return ：删除则为true 否则为假
     */
    public boolean deleteLinkList(T element) {

        Node temp = head;
        if (temp.next == null) {
            System.out.println("链表已空，没有可删除的值");
            return false;
        }
        while (temp.next != null) {
            if (temp.next.data == element) {
                temp.next = temp.next.next;
                return true;
            } else {
                temp = temp.next;
            }
        }
        return false;
    }
    /**
     * 打印
     */
    public void printLinkList() {
        Node temp = head;
        System.out.print("打印单向链表： ");
        while (temp.next != null) {
            temp = temp.next;
            System.out.print(temp.data + " ");
        }
        System.out.println();
    }
    /**
     * 求长度
     *
     * @return ： 返回的长度
     */
    public  int sizeLinkList() {
        Node temp = head;
        int size = 0;
        while (temp.next != null) {
            temp = temp.next;
            size++;
        }
        return size;
    }
    /**
     * 下标删除
     *
     * @param i : 要删除的值下标
     * @return ：删除则为true 否则为假
     */
    public boolean deleteIndexLinkList(int i) {
        Node temp = head;
        int index = -1;
        if (temp.next == null) {
            System.out.println("链表为空，没有可删除的值");
            return false;
        }
        if (i < 0 || i >= sizeLinkList()) {
            System.out.println("下标越界");
            return false;
        }
        while (temp.next != null) {
            index++;
            if (index == i) {
                temp.next = temp.next.next;
                return true;
            }
            temp = temp.next;
        }
        return false;

    }
    /**
     * 给定值求下标
     *
     * @param element ：要找的元素
     *  返回值 index 如果为-1 则没有找到
     */
    public int GetIndexByData(T element) {
        Node temp = head;
        int index = -1;
        if (temp.next ==null) {
            System.out.println("链表为空,无法查找！");
            return index;
        }
        while (temp.next != null) {
            temp = temp.next;
            index++;
            if (temp.data == element) {
                System.out.println("下标为： " + index);
                return index;
            }
        }
        System.out.println("要查找的值不存在！");
        return index;
    }
    /**
     * 给定下标求值
     * @param index
     */
    public Object getDataByIndex(int index) {
        Node temp = head;
        int size= 0;           //为增加下标用的
        if (temp.next == null) {
            System.out.println("链表为空，没有可查询的值！");
            return null;
        }
        if (index >= sizeLinkList() || index < 0){
            System.out.println("下标越界");
            return null;
        }

        while (temp.next !=null){
            temp = temp.next;
            if (size == index){
                return  temp.data;
            }
            size++;
        }
        return null;
    }
}

//自建链栈
public class LinkStack<T>  {
    private static Node top=null;
    /**
     * 初始化
     */
    public void initLinkStack(){
        top=new Node();
        top.data=null;
        top.next=null;
    }
    /**
     * 入栈，插入节点
     * @param element ：节点元素值
     */
    public void pushLinkStack(T element) {
        if (element == null) {
            throw new NullPointerException("参数不能为空");
        }
        Node node = new Node(); //生成节点
        node.data = element;
        if (top == null) {
            top = node;
        } else {
            Node temp = top;
            top=node;
            node.next=temp;
        }
    }
    /**
     * 出栈，删除栈顶元素
     *
     * @param element : 要删除的值
     * @return ：删除则为true 否则为假
     */
    public Object popLinkStack() {
        Object result;
        if (top == null) {
            System.out.println("链栈已空，没有可出栈的元素");
            return null;
        } else {
            result=top.data;
            top= top.next;
            return result;

        }
    }
    /**
     * 打印
     */
    public void printLinkStack() {
        Node temp = top;
        System.out.print("打印链栈表： ");
        while (temp.next != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }
    /**
     * 求链栈长度
     *
     * @return ： 返回的长度
     */
    public  int sizeLinkStack() {
        Node temp = top;
        int size = 0;
        while (temp.next != null) {
            temp = temp.next;
            size++;
        }
        return size;
    }
}

//反向输出链表
public class AntitoneLinkList {
    public static void main(String[] args){
        //生成一个单向链表
        LinkList<Integer> linkList=new LinkList();
        //初始化
        linkList.initLinkList();
        //循环输入数字
        for (int i=1;i<=5;i++){
            linkList.insertLinkList(Integer.valueOf(i));
        }
        //生成一个栈
        LinkStack<Integer> linkStack=new LinkStack();
        //栈初始化
        linkStack.initLinkStack();
        //给栈赋值
        for (int j=0;j<5;j++){
            Integer integI=(Integer)linkList.getDataByIndex(j);
            linkStack.pushLinkStack(integI);
        }
        //打印原链表
        linkList.printLinkList();
        //打印栈
        linkStack.printLinkStack();

        //生成一个新的单向链表
        LinkList<Integer> linkListNew=new LinkList();
        //初始化
        linkListNew.initLinkList();
        //给新链表赋值
        int sizeStack=linkStack.sizeLinkStack();
        for(int k=0;k<sizeStack;k++){
            Integer intI=(Integer)linkStack.popLinkStack();
            linkListNew.insertLinkList(intI);
        }

        //打印新链表
        System.out.println("*****输出反向链表*****");
        linkListNew.printLinkList();

    }
}

输出：