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

题目：

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

public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

思路：

• 从尾到头，我们首先想到的就是栈这个结构，栈是先进先出的结构，先进来的元素最后再出去，所以本题我们可以考虑用栈来解决
• 想到栈的同时我们也应该联想到递归

代码：

 import java.util.Stack;

 import org.junit.jupiter.api.Test;

 /**
  *   反向打印链表
  * @author wydream
  *
  */

 public class PrintList {

     class ListNode{
         Object key;
         ListNode next;
         public ListNode(Object key) {
             this.key=key;
             this.next=null;
         }
     }

     //采用栈
     public void printListRever(ListNode node) {
         Stack<ListNode> stack=new Stack<ListNode>();
         while(node!=null) {
             stack.push(node);
             node=node.next;
         }
         while(!stack.empty()) {
             System.out.println(stack.pop().key);
         }
     }

     //采用递归
     public void printListReverdg(ListNode node) {
         if(node!=null) {
             printListReverdg(node.next);
             System.out.println(node.key);
         }else {
             return;
         }
     }

     //=============测试代码=============
     @Test
     public void test() {
         ListNode ListNode1 = new ListNode(1);
         ListNode ListNode2 = new ListNode(2);
         ListNode ListNode3 = new ListNode(3);
         ListNode ListNode4 = new ListNode(4);
         ListNode ListNode5 = new ListNode(5);
         ListNode1.next=ListNode2;
         ListNode2.next=ListNode3;
         ListNode3.next=ListNode4;
         ListNode4.next=ListNode5;
         System.out.println("采用栈：");
         printListRever(ListNode1);
         System.out.println("采用递归：");
         printListReverdg(ListNode1);
     }

 }