数据结构与算法-剑指Offer系列（5）从头到尾打印链表-Java实现

题目6：从头带我打印链表

题目描述：

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

解题思路：

遍历是从头到尾，但是输出是从尾到头，也就是第一个遍历的节点最后输出，最后一个节点第一个输出，典型的“后进先出-LIFO“，可以用栈实现这种顺序。每经过一个节点的时候，把该节点放到一个栈中，当遍历完整个链表后，再从栈顶输出每个节点的值。

代码如下：

	public static void PrintByStack(ListNode root) {
		Stack<ListNode> stack = new Stack<>();
		while(root!=null) {
			stack.add(root);
			root = root.next;
		}
		
		while(!stack.isEmpty()) {
			ListNode node = stack.peek();
			System.out.println(node.val);
			stack.pop();
		}
	}

 

想到栈，也会想到使用递归来实现。使用递归根据另一篇博客的，递归实现，主要是 每访问到一个节点，先递归输出它 后面的节点，再输出本身，这样的结果就反过来了，同时当链表为空时，停止递归，算法实现如下：

package swordToOffer;

import java.util.Stack;

public class Num5_PrintListInReverseOrder {
	
	static class ListNode{
		int val;
		ListNode next;
		ListNode(int val){
			this.val=val;
			this.next=null;
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ListNode nullNode = null;
		System.out.println("采用栈：");
		PrintByStack(nullNode);
		System.out.println("采用递归：");
		PrintByRecursive(nullNode);
		
		ListNode l1= new ListNode(1);
		ListNode l2= new ListNode(2);
		ListNode l3= new ListNode(3);
		ListNode l4= new ListNode(4);
		ListNode l5= new ListNode(5);
		l1.next=l2;
		l2.next=l3;
		l3.next=l4;
		l4.next=l5;
		System.out.println("采用栈：");
		PrintByStack(l1);
		System.out.println("采用递归：");
		PrintByRecursive(l1);
		
		ListNode ll = new ListNode(1);
		
		System.out.println("采用栈：");
		PrintByStack(ll);
		System.out.println("采用递归：");
		PrintByRecursive(ll);
	}

	public static void PrintByStack(ListNode root) {
		Stack<ListNode> stack = new Stack<>();
		while(root!=null) {
			stack.add(root);
			root = root.next;
		}
		
		while(!stack.isEmpty()) {
			ListNode node = stack.peek();
			System.out.println(node.val);
			stack.pop();
		}
	}
	
	public static void PrintByRecursive(ListNode root) {
		if(root!=null) {
			PrintByRecursive(root.next);			
			System.out.println(root.val);
		}else {
			return;
		}
	}
	
	
}

 分析

• 在编程中遇到先入后出、后进先出可以考虑使用栈stack实现
• 同时使用栈也可以使用递归实现