import java.util.Stack;
/**
 * 从尾到头打印链表
 * 题目:输入一个链表的头结点，从尾到头反过来打印出每个结点的值。等价于反转链表
 * 
 * 考察:单链表的理解，对循环、递归和栈3个相互关联的概念理解
 * 
 * 考虑:是否允许改变链表的结构
 */
public class LinkListReverse {
	
	//使用栈结构存储结点值。----------不改变链表结构
	public static void printLinkListReverse_1(ListNode head) {
		if(head == null) {
			return;
		}
		Stack<Integer> stack = new Stack<Integer>();
		ListNode node = head;
		//将结点依次压入栈中
		while(node != null) {
			stack.push(node.val);
			node = node.next;
		}
		//循环弹出栈数据
		while(!stack.isEmpty()) {
			if(stack.size() == 1) {
				System.out.print(stack.pop());
			}else {
				System.out.print(stack.pop()+"->");
			}
		}
	}
	
	//使用递归的方式，递归的本质是一个栈结构，每次访问一个结点的时候，先递归输出它后面的结点。----不改变链表结构
	public static void printLinkListReverse_2(ListNode head) {
		if(head == null) {
			return;
		}
		if(head != null) {
			if(head.next != null) {
				printLinkListReverse_2(head.next);
			}
			System.out.print(head.val+"\t");
		}
	}
	
	//将链接结点的指针反转过来，改变链表的方向。-------改变链表结构
	public static ListNode printLinkListReverse_3(ListNode head) {
		if(head == null || head.next == null) {
			return head;
		}
		ListNode node = null;
		ListNode pre = null;
		while(head != null) {
			node = head.next;
			head.next = pre;
			pre = head;
			head = node;
		}
		return pre;
	}
	
	public static void main(String[] args) {
		ListNode l10 = new ListNode(1);
		ListNode l11 = new ListNode(2);
		ListNode l12 = new ListNode(2);
		ListNode l13 = new ListNode(4);
		ListNode l14 = new ListNode(5);
		ListNode l15 = new ListNode(4);
		l10.next = l11;
		l11.next = l12;
		l12.next = l13;
		l13.next = l14;
		l14.next = l15;
		l15.next = null;
		printLinkListReverse_1(l10);
		System.out.println();
		printLinkListReverse_2(l10);
		System.out.println();
		ListNode node = printLinkListReverse_3(l10);
		while(node != null) {
			if(node.next == null) {
				System.out.println(node.val);
			}else{
				System.out.print(node.val +"->");
			}
			node = node.next;
		}
	}

}

class ListNode{
	public int val;
	public ListNode next;
	
	public ListNode(int val) {
		this.val = val;
	}
}