从尾到头打印链表

逆序输出链表，一开始只想到了倒置链表，看了看别人的方法，栈和递归也是可以的。

思路一：倒置链表

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> li = new ArrayList<Integer>();
         if (listNode == null)
            return li;
        if(listNode.next == null)
            return li;
        ListNode head = listNode.next;
        ListNode p= listNode;
        ListNode temp  = listNode;
        while (head != null){
          temp.next = head.next;
          head.next = p;
          p = head;
          head = temp.next;
        }

        while(p != null){
            li.add(p.val);
            p = p.next;
        }
        return li;
    }
}

思路二：用栈实现

/**
     * 2：从头到尾遍历链表，存入栈中
     * 遍历栈
     * @param listNode
     * @return
     */
    public static ArrayList<Integer> printListFromTailToHead_Stack(ListNode node)
    {
        if(node==null){
            return null;
        }
        ArrayList<Integer> list=new ArrayList<Integer>();
        Stack<Integer> s=new Stack<Integer>();
        ListNode temp=node;
        while(temp!=null){
            s.push(temp.val);
            temp=temp.next;
        }
        while(!s.empty()){
            list.add(s.pop());
        }
        return  list;
    }

思路三：递归实现

/**
     * 3：递归节点，每次遇到链表节点，去查询它的next节点，然
     * 后才把该节点的值存入到全局变量result中
     * @param listNode
     * @return
     */
    //全局变量，存放数据
    static ArrayList<Integer> result=new ArrayList<Integer>();
    public static void printListFromTailToHead_Rec(ListNode node)
    {

        ListNode temp=node;
        if(temp!=null){
            printListFromTailToHead_Rec(temp.next);
            result.add(temp.val);
        }
    }