倒序输出链表（递归思想）

给出一个自定义的链表：

public class ListNode {
        int val;
        ListNode next;
        ListNode(int x) { val = x; }
    }

要求将给的链表翻转放入int数组。

方法一：
遍历取出数放入一个list，再依据list大小生成数组，再翻转置进去数值。

public int[] reversePrint1(ListNode head) {
        List<Integer> nums = new ArrayList<>();
        while (head != null) {
            nums.add(head.val);
            head = head.next;
        }

        int[] res = new int[nums.size()];
        int j = 0;
        for (int i = nums.size() - 1; i >= 0; i--) {
            res[i] = nums.get(j++);
        }
        return res;
    }

方法二：
因为倒序也就是先入后出，和堆栈的思维相同：

public int[] reversePrint2(ListNode head) {
        LinkedList<Integer> stack = new LinkedList<>();
        while (head != null) {
            stack.addLast(head.val);
            head = head.next;
        }
        int[] res = new int[stack.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = stack.removeLast();
        }
        return res;
    }

java中的链表有对最后一个元素进行插入或删除的方法，用该方法可模拟出堆栈，接着将数值逐个加入，再将last逐个取出即可。

方法三：

int[] res;
    int i = 0;
    int j = 0;
    public int[] reversePrint(ListNode head) {
        reverse(head);
        return res;
    }

    void reverse(ListNode head) {
        if (head == null) {
            res = new int[i];
            return;
        }
        i++;
        reverse(head.next);
        res[j] = head.val;
        j++;
    }

递归思想，通过递归获取数组大小，因为程序执行到reverse进入递归函数，后续赋值操作不会进行，所以整体是先初始化了数组，再从递归最深处的head的值赋给j从小增加的res。