剑指Offer——从头到尾打印链表

题目链接

https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&tqId=11156&tPage=1&rp=1&ru=/ta/coding-interviews&qru=/ta/coding-interviews/question-ranking

 

题目

 

函数接口

 

题解

本题的思路比较简单，即遍历链表，将其倒序存放到一个ArrayList中，并进行返回。

根据题意不难理解，这里给出的是一个单向链表，由于单向链表的特性。不可能直接从尾到头进行输出，所以一个简单的思路就是利用另一个集合容器，存放取出的值，通过正序的读取，最后完成倒序的输出。

先进后出，不难想到栈这个数据结构。方法一中，就是基于这一数据结构解决该题的。

 

方法一

具体的说，对于该题，首先遍历链表，并将每个节点的val依次压入一个栈中。最后遍历这个栈，将栈中元素依次出栈到ArrayList中。这样得到的ArrayList就相当于从后往前遍历链表的结果了。

实现代码如下

import java.util.ArrayList;
import java.util.Stack;

public class Solution {
    public ArrayList printListFromTailToHead(ListNode listNode) {
        Stack stack = new Stack<>();
        ArrayList list = new ArrayList<>();
        while (listNode != null) {
            stack.push(listNode.val);
            listNode = listNode.next;
        }
        while (!stack.empty()) {
            list.add(stack.pop());
        }
        //stack.clear();
        return list;
    }
}

需要注意的是由于使用Stack这个集合，所以需要导包import java.util.Stack;

同时使用完stack之后可以选择进行clear清空。但是可能会略微影响效率。

 

方法二

对于该问题，另一个易得的思路是直接将遍历链表的值依次存入一个ArrayList中，最后再将这个ArrayList进行翻转，最后得到的新ArrayList也相当于反序遍历链表的结果。

由于ArrayList底层是数组实现，进行翻转的时间复杂度并不算高（约为O(n/2)）。

当然这里的ArrayList也可以是一个Integer的数组，最后一步利Arrays.asList()转为ArrayList即可。

实现方法很多样，本文为了减少编码时间，缩减代码量。采用了Java集合自带的方法Collections.reverse(list);

代码如下

import java.util.ArrayList;
import java.util.Collections;

public class Solution {
    public ArrayList printListFromTailToHead(ListNode listNode) {
        ArrayList list = new ArrayList<>();
        while (listNode != null) {
            list.add(listNode.val);
            listNode = listNode.next;
        }
        Collections.reverse(list);
        return list;
    }
}

注意导包import java.util.Collections;

 

方法三

前两种方法都是使用了集合的一些特性或者方法。那么有没有一种更为简单的思路呢。

答案是肯定的。

相信大家应该都有所了解。在数据结构的学习过程中，遍历一个链表有两种方式，一种是利用循环，一种是使用递归。对于该题来说，使用递归也是可行的。

该题的递归思路，可以先对ListNode进行不断递归，一直到尾节点后，开始return，但这个return的意义，主要是用于返回上一层，除了第一次调用能够返回一个完整的、题目需要的ArrayList外。其他层的return都仅仅是为了返回上一层递归。

实际上为ArrayList赋值的过程发生在递归语句之后，只有这样，才能保证先遍历到尾，再从尾到头依次存储链表元素。

实现代码如下

import java.util.ArrayList;

public class Solution {
    ArrayList list = new ArrayList<>();

    public ArrayList printListFromTailToHead(ListNode listNode) {
        if (listNode == null)
            return list;
        printListFromTailToHead(listNode.next);
        list.add(listNode.val);
        return list;
    }
}

这一思路的好处是不需要导包，代码量也不大。

但缺点也显而易见，时空开销大，同时因为递归的使用也容易发生内存泄漏。

 

综上，是笔者对于该题的一点理解。如果有更好的思路欢迎大家在评论区分享。