剑指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方法，取巧借用了封装的方法，但是效率应该是最高的。