剑指offer——面试题6：从尾到头打印单向链表

题目：

输入一个链表，从尾到头打印链表每个节点的值。

思路1：
遍历链表，将节点值保存在栈中，利用栈的先进后出性质

class ListNode {
public int val;
public ListNode next;

public ListNode(int val) {
this.val = val;
}
}
public class T6 {
//方法一：逆序返回队列,利用堆栈
public static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list = new ArrayList<Integer>();
Stack<Integer> stack = new Stack<>();
while (listNode != null) {
stack.push(listNode.val);
listNode = listNode.next;
}
while (!stack.isEmpty()) {
list.add(stack.pop());
}
return list;
}

public static void main(String[] args) {
ListNode list = new ListNode(1);
list.next = new ListNode(2);
list.next.next = new ListNode(3);
list.next.next.next = new ListNode(4);
list.next.next.next.next = new ListNode(5);
ArrayList<Integer> list1 = printListFromTailToHead(list);
for(int i=0;i<list1.size();i++){
System.out.println(list1.get(i));
}
}
}

思路2：

用递归的性质。递归在本质上就是一个栈结构

当链表非常长的时候，就会导致函数调用的层级很深，从而可能导致函数调用栈溢出。
这样比较看来，思路1鲁棒性更好。

class ListNode {
public int val;
public ListNode next;

public ListNode(int val) {
this.val = val;
}
}
public class T6 {
//利用递归
public static ArrayList<Integer> arrayList=new ArrayList<Integer>();
public static ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode!=null){
printListFromTailToHead(listNode.next);
arrayList.add(listNode.val);
}
return arrayList;
}
public static void main(String[] args) {
ListNode list = new ListNode(1);
list.next = new ListNode(2);
list.next.next = new ListNode(3);
list.next.next.next = new ListNode(4);
list.next.next.next.next = new ListNode(5);
ArrayList<Integer> list1 = printListFromTailToHead(list);
for(int i=0;i<list1.size();i++){
System.out.println(list1.get(i));
}
}
}

思路3：

改变链表的指针顺序，将指针从尾指向头，后面有一题改变指针方向题，这里就不写了。。

如：1->2->3->4->5->6->7

改为：1<-2<-3<-4<-5<-6<-7

面试拓展：

能否修改输入的数据，最好先问面试官，是否允许修改(想利用思路3之前最好和面试官沟通清楚)