这是我参与11月更文挑战的第4天，活动详情查看：2021最后一次更文挑战

从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

 

示例 1：

输入：head = [1,3,2] 输出：[2,3,1]  

限制：

0 <= 链表长度 <= 10000

题解

方法一：栈——Java

栈的特点是后进先出，即最后压入栈的元素最先弹出。

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

创建一个栈，用于存储链表的节点

创建一个指针，初始时指向链表的头节点

当指针指向的元素非空时，重复下列操作：

将指针指向的节点压入栈内

将指针移到当前节点的下一个节点

获得栈的大小 size，创建一个数组 print，其大小为 size

创建下标并初始化 index = 0

重复 size 次下列操作：

从栈内弹出一个节点，将该节点的值存到 print[index]

将 index 的值加 1

class Solution {
    public int[] reversePrint(ListNode head) {
        LinkedList<Integer> stack = new LinkedList<Integer>();
        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;
    }
}

时间复杂度：O（N）

空间复杂度：O（N）

方法二：递归法——Java

利用递归： 先走至链表末端，回溯时依次将节点值加入列表 ，这样就可以实现链表值的倒序输出。

递推阶段： 每次传入 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）

空间复杂度：O（N）

方法二：递归法——Go

递归法——Go版本

/**
 * Definition for singly-linked list.
 * type ListNode struct {
 *     Val int
 *     Next *ListNode
 * }
 */
func reversePrint(head *ListNode) []int {
    if head == nil {
        return nil
    }

    return appendData(head)
}

func appendData(head *ListNode) []int {
    if head.Next != nil{
        list := appendData(head.Next)
        list = append(list, head.Val)
        return list
    }

    return []int{head.Val}
}