【剑指offer】第06题 从尾到头打印链表

【剑指offer】第06题 从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

示例 1：

输入：head = [1,3,2]
输出：[2,3,1]

限制：

0 <= 链表长度 <= 10000

第一种解法：将链表中链接节点的指针反转过来，改变链表的方向，这样就可以从尾到头输出了。但这样会改变链表的结构。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> l=new ArrayList<>();
    public int[] reversePrint(ListNode head) {
        print(head);
        int size=l.size();
        int[] res=new int[size];
        for(int i=0;i<size;i++){
            res[i]=l.get(i);
        }
        return res;
    }
    void print(ListNode head){
        if(head==null) return;
        print(head.next);
        l.add(head.val);
    }
}

第二种解法：因为链表的顺序时从头到尾，而输出的确实从尾到头，也就是第一个节点最后输出，最后一个节点第一个输出，这就是典型的先进后出。所以可以用栈来模拟输出。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
       Stack<ListNode> stack = new Stack<ListNode>();
        ListNode temp = head;
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        int size = stack.size();
        int[] print = new int[size];
        for (int i = 0; i < size; i++) {
            print[i] = stack.pop().val;
        }
        return print;
    }
    
}

第三种解法：因为递归本身就是一种栈结构，所以可以用递归的方式。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    List<Integer> list=new ArrayList<>();
    public int[] reversePrint(ListNode head) {
       rescue(head);
       int[] print=new int[list.size()];
       for(int i=0;i<list.size();i++){
           print[i]=list.get(i);
       }
       return print;
    }
    void rescue(ListNode ListNode){
        if(ListNode==null) return;
        rescue(ListNode.next);
        list.add(ListNode.val);
    }
    
}