剑指Offer面试题5（Java版）：从尾到头打印链表

题目：输入一个链表的头结点，从尾到头反过来打印出每个节点的值。

实现代码如下：

public class test1 {
	
    public static void main(String[] args){
    	LinkedListTest llt1=new test1().new LinkedListTest(1);
    	LinkedListTest llt2=new test1().new LinkedListTest(2);
    	LinkedListTest llt3=new test1().new LinkedListTest(3);
    	LinkedListTest llt4=new test1().new LinkedListTest(4);
    	LinkedListTest llt5=new test1().new LinkedListTest(5);
    	LinkedListTest llt6=new test1().new LinkedListTest(6);
    	llt1.nextCode=llt2;
    	llt2.nextCode=llt3;
    	llt3.nextCode=llt4;
    	llt4.nextCode=llt5;
    	llt5.nextCode=llt6;
    	printLBTrailtoHead1(llt1);
	}
    
    class LinkedListTest{
    	private LinkedListTest nextCode=null;
    	private int Data;
    	
    	public LinkedListTest(int Data){
    		this.Data=Data;
    	}
    	
    }
    /**
     * 递归从尾到头打印列表
     * @param llt
     */
    public static void printLBTrailtoHead(LinkedListTest llt){
    	if(llt!=null){
    		if(llt.nextCode!=null)
    			printLBTrailtoHead(llt.nextCode);
    		System.out.println(llt.Data);
    	}
    	
    }
    /**
     * 采用循环方式，虽然循环了2*n次，但是可以避免递归的函数栈溢出问题
     * @param llt
     */
    public static void printLBTrailtoHead1(LinkedListTest llt){
    	Stack<LinkedListTest> stack=new Stack<test1.LinkedListTest>();
    	while(llt!=null){
    		stack.push(llt);
    		llt=llt.nextCode;
    	}
    	while(!stack.empty()){
    		System.out.println(stack.pop().Data);
    	}
    	
    }
    
}

学到的：

1.递归调用函数，层级太深时，由于函数反复调用，会造成函数数量急剧增长，会对系统的栈造成很大压力，容易栈溢出。

虽然时间复杂度差不多，但还是建议用循环方式，稳妥一点。

2.对链表的数据结构有了更深的认识，链表分为单链表、双链表、循环链表，本文使用的是单链表。

参考：http://blog.csdn.net/jsqfengbao/article/details/47053189