剑指 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 {
    void dfs(ArrayList<Integer> res,ListNode p)
    {
        if(p==null) return;
        dfs(res,p.next);
        res.add(p.val);
    }
    public int[] reversePrint(ListNode head) {
        ArrayList<Integer> arrayList = new ArrayList<>();
        dfs(arrayList,head);
        int res[] = new int[arrayList.size()];
        for(int i=0; i<arrayList.size(); ++i){
            res[i] = arrayList.get(i);
        }
        return res;
    }
}

链表遍历

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public int[] reversePrint(ListNode head) {
        ListNode p;
        p = head;
        int n = 0;
        while(p!=null){
            p=p.next;
            n++;
        }
        int ans[] = new int[n];
        p = head;
        while(p!=null){
            ans[--n] = p.val;
            p = p.next;
        }
        return ans;
    }
}

用栈

/**
 * 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> s = new Stack<>();
        ListNode p = head;
        while(p!=null){
            s.push(p);
            p=p.next;
        }
        int n = s.size();
        int []ans = new int[n];
        for(int i=0; i<n; ++i){
            ans[i] = s.pop().val;
        }
        return ans;
    }
}