剑指offer-面试题6：从尾到头打印链表

题目描述

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

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

限制： 0 <= 链表长度 <= 10000

方法一（递归）

1.解题思路

递归到链表的末端，然后依次回溯，逆序地把每一个节点添加到预先准备好的list容器，最后再将list转化为数组即可。

2.代码实现

class Solution {
    ArrayList<Integer> list=new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        printFromTailToHead(head);
        int n=list.size();
        int[] res=new int[n];
        for(int i=0;i<n;i++){
            res[i]=list.get(i);
        }
        return res;
    }
    private void printFromTailToHead(ListNode head){
        if(head!=null){
            this.printFromTailToHead(head.next);
            list.add(head.val);
        }
    }
}

java8的Stream操作实现：

class Solution {
    ArrayList<Integer> list=new ArrayList<Integer>();
    public int[] reversePrint(ListNode head) {
        printFromTailToHead(head);
        return list.stream().mapToInt(Integer::valueOf).toArray();
    }
    private void printFromTailToHead(ListNode head){
        if(head!=null){
            this.printFromTailToHead(head.next);
            list.add(head.val);
        }
    }
}

3.复杂度分析

• 时间复杂度：递归栈的深度为链表的长度，所以复杂度为O(n)
• 空间复杂度：需要额外长度为n的递归栈开销，复杂度为O(n)

方法二（利用栈实现）

1.解题思路

遍历链表，将每个节点的值依次存入栈，利用栈先进后出的特性，将栈的元素按顺序弹出并存入结果数组即可。

2.代码实现

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

3.复杂度分析

• 时间复杂度：需要遍历整个链表，所以复杂度为O(n)
• 空间复杂度：需要额外创建栈，复杂度为O(n)

方法三（倒序存储）

1.解题思路

遍历链表，计算出链表的长度，然后创建对应长度的结果数组，直接将链表节点值倒序存储到结果数组，需要两次遍历，但是不需要额外的空间。

2.代码实现

class Solution {
    public int[] reversePrint(ListNode head) {
        int len=0;
        ListNode p=head;
        while(p!=null){
            len++;
            p=p.next;
        }
        int[] res=new int[len];
        while(head!=null){
            res[--len]=head.val;
            head=head.next;
        }
        return res;
    }
}

3.复杂度分析

• 时间复杂度：需要遍历整个链表，所以复杂度为O(n)
• 空间复杂度：不需要额外空间，复杂度为O(1)

剑指offer全集入口： 请戳这里