（java版剑指offer）JZ6 从尾到头打印链表（四种方法）

方法一：反转链表+ArrayList遍历 方法二：ArrayList遍历+Collections.reverse() 方法三：利用list.add(0, listNode.val) 方法四：利用栈的先进后出，反转，从而放入数组列表ArrayList中

//方法一：反转链表+ArrayList遍历
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;


public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        //先反转链表，在放入list中
        ArrayList<Integer> list=new ArrayList<>();    //实例化数组列表
        ListNode pre=null;    //定义指向为空的引用pre
        ListNode cur=listNode;    //定义指向头结点的引用listNode
        ListNode temp=cur;    //把当前节点的位置cur保存起来
        while(cur != null){    //cur指向的节点不为空
            temp=cur.next;    //保存下一个节点的位置
            cur.next=pre;    //把当前cur指向的节点的指针域指向之前的节点pre
            pre=cur;    //上面完成后，此时当前的节点cur变成之前的节点pre,为循环做准备
            cur=temp;    //把之前暂存的节点的位置temp还回给指向当前节点cur，为循环做准备
        }
        while(pre != null){    //当反转后的链表不为空
            list.add(pre.val);    //遍历链表，把链表的各结点的值拼接到数组列表list上
            pre=pre.next;    //为遍历做准备
        }
        return list;    //返回链表
    }
}

//方法二：ArrayList遍历+Collections.reverse()
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;

public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();
        
        while(listNode != null){
            list.add(listNode.val);    //拼接链表节点的值
            listNode = listNode.next;    //指向下一节点，为循环做准备
        }
        Collections.reverse(list);    //直接反转链表
        return list;
    }
}

//方法三：利用list.add(0, listNode.val)
//在数组列表同一位置，放置元素，之前的已放元素不断往后移动
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;


public class Solution {
    ArrayList<Integer> list = new ArrayList<>();
        public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
            ArrayList<Integer> list=new ArrayList<>();    //实例化数组列表对象
            while(listNode != null){    //指针域不为空
                list.add(0,listNode.val);    //在列表同一位置放置元素，列表之前的元素会一直往后移动
                listNode=listNode.next;    //指向下一个节点
            }
            return list;
    }
}

//方法四：利用栈的先进后出，反转，从而放入数组列表ArrayList中
/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.*;


public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list=new ArrayList<>();    //实例化数组列表
        Stack<Integer> stack=new Stack<>();    //实例化一个整数栈
        while(listNode != null){    //若节点不为空
            stack.push(listNode.val);    //节点的值压入栈中
            listNode=listNode.next;    //指向下一个节点
        }
        while(!stack.empty()){    //若栈不为空
            list.add(stack.pop());    //将栈中弹出的值拼接在lis里面，利用栈先进后出，实现逆序排列
        }
        return list;
    }
}