从尾到头打印链表

@author: sdubrz
@date: 2020.05.03
@e-mail: lwyz521604#163.com
题目来自《剑指offer》 电子工业出版社

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

示例 1：

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

限制：

0 <= 链表长度 <= 10000

我的解法

一种比较容易想到的方法就是用栈来把顺序颠倒：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
import java.util.*;
class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<Integer> stack = new Stack<>();
        while(head!=null){
            stack.push(head.val);
            head = head.next;
        }

        int n = stack.size();
        int[] nums = new int[n];
        for(int i=0; i<n; i++){
            nums[i] = stack.pop();
        }

        return nums;
    }
}

在 LeetCode 系统中提交的结果如下所示

执行结果： 通过 显示详情
执行用时 : 2 ms, 在所有 Java 提交中击败了 57.13% 的用户
内存消耗 : 40.9 MB, 在所有 Java 提交中击败了 100.00% 的用户

官方解法

官方给出的解法也是使用的栈。不过他的栈中存储的是链表节点，而不是链表节点的数值。但是其实际运行速度要比我的稍快一些，这或许可以作为以后解题的技巧。下面是其具体的代码实现

class Solution {
    public int[] reversePrint(ListNode head) {
        Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
}

在 LeetCode 系统中提交的结果如下，实际运行速度要比我的代码稍快。

执行结果： 通过 显示详情
执行用时 : 1 ms, 在所有 Java 提交中击败了 80.18% 的用户
内存消耗 : 40.1 MB, 在所有 Java 提交中击败了 100.00% 的用户