题目介绍

方法一：栈

栈的特点是后进先出，即最后压入栈的元素最先弹出。考虑到栈的这一特点，使用栈将链表元素顺序倒置。从链表的头节点开始，依次将每个节点压入栈内，然后依次弹出栈内的元素并存储到数组中。

创建一个栈，用于存储链表的节点，创建一个指针，初始时指向链表的头节点，当指针指向的元素非空时，重复下列操作：

将指针指向的节点压入栈内
将指针移到当前节点的下一个节点
获得栈的大小 size，创建一个数组 print，其大小为 size
创建下标并初始化 index = 0
重复 size 次下列操作：
- 从栈内弹出一个节点，将该节点的值存到 print[index]
- 将 index 的值加 1
返回 print

代码如下：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode tempHead = head;
        Stack<ListNode> stack = new Stack<>();
        while(tempHead != null) {
            stack.push(tempHead);
            tempHead = tempHead.next;
        }
        int  n = stack.size();
        int[] print = new int[n];
        for(int i = 0 ; i < n ; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

复杂性分析

时间复杂度：O(n)。正向遍历一遍链表，然后从栈弹出全部节点，等于又反向遍历一遍链表。
空间复杂度：O(n)。额外使用一个栈存储链表中的每个节点。

方法二：递归

既然想到了用栈，而递归本质上就是一个栈结构，要实现反过来输出链表，每访问到一个节点的时候，先递归输出它后面的节点，再输出该节点自身，这样链表的输出结果就反过来了。

递推阶段：每次传入 head.next ，以 head == null（即走过链表尾部节点）为递归终止条件，此时直接返回。
回溯阶段：层层回溯时，将当前节点值加入列表，即tmp.add(head.val)。最终，将列表 tmp 转化为数组 res ，并返回即可。

代码如下：

class Solution {
    ArrayList<Integer> tmp = new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        recur(head);
        int[] res = new int[tmp.size()];
        for(int i = 0; i < res.length; i++) {
            res[i] = tmp.get(i);
        }
        return res;
    }
    void recur(ListNode head) {
        if(head == null) {
            return;
        }
        recur(head.next);
        tmp.add(head.val);
    }
}

复杂度分析

时间复杂度 O(N)：遍历链表，递归 N 次。
空间复杂度 O(N)：系统递归需要使用 O(N)的栈空间。

剑指 Offer 06. 从尾到头打印链表

题目介绍

方法一：栈

方法二：递归