剑指offer（三）从尾到头打印链表

• 题目
  
  • 输入一个链表，从尾到头打印链表每个节点的值。
• 案例
  
  • 输入一个链表，将值打印出来（我的案例上是将值放到ArrayList中去）

    ListNode root = new ListNode();      root.val = 1;      root.nxt = new ListNode();      root.nxt.val = 2;      root.nxt.nxt = new ListNode();      root.nxt.nxt.val = 3;      root.nxt.nxt.nxt = new ListNode();      root.nxt.nxt.nxt.val = 4;      root.nxt.nxt.nxt.nxt = new ListNode();      root.nxt.nxt.nxt.nxt.val = 5;

输出或返回 [5, 4, 3, 2, 1]

• 分析题目
  
  • 大家都知道，链表类结构，简单说，就是不断向子集嵌套的结构。
  • 所以我的第一想法就是用递归，然后也实现出来通过了
  • 但是我想应该不会那么简单吧，递归也太简单了
  • 果不其然，网上好多都是用容器vector和配接器stack来实现
  • 然后又查了一下，又想到一种方法。Collections的reverse();
• 解题代码（一）：递归

import java.util.ArrayList;public class Solution {    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {        ArrayList<Integer> list = new ArrayList<Integer>();        if( listNode != null )            println(listNode, list);        return list;    }    private void println(ListNode listNode, ArrayList<Integer> list){        if( listNode.next != null )        {            println(listNode.next, list);        }        list.add(listNode.val);    }}

• 解题代码（二）：用容器vector和配接器stack来实现

/**     * 剑指offer（从尾到头打印链表）     * @param listNode     * @return     */    public static ArrayList<Integer> printListFromTailToHeadSecond(ListNode listNode) {        ArrayList<Integer> list = new ArrayList<Integer>();        if(listNode == null)            return list;        Stack<Integer> stack = new Stack<Integer>();        ListNode temp = listNode;        while(temp != null){            stack.push( temp.val );            temp = temp.next;        }        while( !stack.empty() ){            list.add( stack.pop() );        }        return list;    }

• 解题代码（三）：

import java.util.Collections;import java.util.ArrayList;/** * 剑指offer（从尾到头打印链表） * @param listNode * @return */public class Solution {    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {        ArrayList<Integer> list = new ArrayList<Integer>();        if( listNode == null )            return list;        ListNode temp = listNode;        while(temp != null){            list.add( temp.val );            temp = temp.next;        }        Collections.reverse(list);        return list;    }}

• 总结
  
  • 第一种递归虽然代码简洁，看似效率比较高，但是如果链表太长的话，递归太深，则容易造成堆栈的溢出
  • 第二种是将链表的值从头到尾加入栈中，这样栈输出的时候，就会是倒着的
  • 第三种直接放入list中，然后利用Collections的reverse方法，取巧借用了封装的方法，但是效率应该是最高的。